def LaneDetector_Test(pic_dir, ipm, LaneMarker, laneDetectorModel): filenames = io_util.load_fnames(pic_dir) ftmp1 = cv2.imread(os.path.join(pic_dir, filenames[0]), cv2.IMREAD_GRAYSCALE).astype('uint8') for i in range(len(filenames)): display.show_progressbar(i, filenames) ftmp = cv2.imread(os.path.join(pic_dir, filenames[i]), cv2.IMREAD_GRAYSCALE).astype('float') ipm_img = ipm.imageToIPM(ftmp) lanemarker_img = laneMarker.detect(ipm_img, 5) threshold_img = image_util.thresholdImage(lanemarker_img, 95) # cv2.imshow('ipm', ipm_img.astype('uint8')) # cv2.imshow('lanemarker', lanemarker_img.astype('uint8')) # cv2.imshow('threshold_img', threshold_img.astype('uint8')) degree = 1 lanes = laneDetectorModel.updateLaneModel(threshold_img, degree) # Save lanes for lane in lanes: xns, yns = convertIPMLaneToLane(lane, ipm) pt1 = (int(xns[0]), int(yns[0])) pt2 = (int(xns[-1]), int(yns[-1])) cv2.line(ftmp, pt1, pt2, (255, 0, 0), 5) cv2.imshow('img', ftmp.astype('uint8')) cv2.waitKey(15) print "" cv2.destroyAllWindows()
def following_analysis(relativepath, distances_fn='follow_distance_speed.json'): filenames = io_util.load_fnames(relativepath) follow_dict = io_util.load_json(relativepath, distances_fn) speed_dict = io_util.load_json(relativepath, 'true_speed.json') distances = [] speeds = [] true_speeds = [] for fname in filenames: if fname in follow_dict: distances.append(follow_dict[fname]['distance']) speeds.append(follow_dict[fname]['speed']) true_speeds.append(speed_dict[fname]) print 'Pearson coefficient and pvalue:', print pearsonr(distances, speeds) print 'Pearson coefficient and pvalue with true speed:', print pearsonr(distances, true_speeds) plt.figure(1) plt.scatter(distances, speeds) plt.xlabel('Following distance to car in front (ft)') plt.xlim([20, 60]) plt.ylim([60, 80]) plt.ylabel('Speed (MPH)') plt.show() plt.figure(2) plt.scatter(distances, true_speeds) plt.xlabel('Following distance to car in front (ft)') plt.xlim([20, 60]) plt.ylim([60, 72]) plt.ylabel('Speed (MPH)') plt.show()
def VehicleDetector_Test(svm, pic_dir): vd = VehicleDetector.VehicleDetector(svm) font = cv2.FONT_HERSHEY_PLAIN # Read the filenames from the list.txt file init_frame = 1000 filenames = io_util.load_fnames(pic_dir)[init_frame:init_frame + 50] for i in range(len(filenames)): display.show_progressbar(i, filenames) ftmp = cv2.resize( cv2.imread(os.path.join(pic_dir, filenames[i]), cv2.IMREAD_GRAYSCALE).astype('uint8'), (320, 240)) boxes = vd.update(ftmp) for vehicle_box in boxes: [x1, y1, x2, y2] = vehicle_box['box'].astype(np.int64) box_id = vehicle_box['id'] cv2.rectangle(ftmp, (x1, y1), (x2, y2), color=(255, 0, 0)) cv2.putText(ftmp, "Id:{}".format(box_id), (x1, y1 - 5), font, 1, color=(255, 0, 0)) cv2.imshow('img', ftmp) cv2.waitKey(1) print "" cv2.destroyAllWindows()
def get_nearby_lanes(relativepath, threshold=0.125, lane_fname='lanes_output_new.json', vp_fname='vp.json'): print 'Finding nearby lanes for {}'.format(relativepath) filenames = io_util.load_fnames(relativepath) fname_lanes_dict = io_util.load_json(relativepath, lane_fname) vp_dict = io_util.load_json(relativepath, vp_fname) vp = vp_dict['vp'] initimg = cv2.imread(os.path.join(relativepath, filenames[0]), cv2.IMREAD_GRAYSCALE) imgshape = initimg.shape imgheight, imgwidth = imgshape origPts, destPts = image_util.locateROI(imgshape, x_frac=1/3., y_frac_top=1/25., y_frac_bot=1/6., vp=vp) ipm = IPM.IPM(imgshape, imgshape, origPts, destPts) new_fname_json = {} for fname in filenames: if fname in fname_lanes_dict: lanes = fname_lanes_dict[fname] distances = [] for lane in lanes: dist = distToCenter(lane, ipm) distances.append((dist, lane)) if len(distances) >= 2: distances.sort(key=lambda x:abs(x[0])) if abs(abs(distances[0][0]) - abs(distances[1][0])) < threshold: if (distances[0][0] <= 0 and distances[1][0] >= 0): new_fname_json[fname] = [distances[0][1], distances[1][1]] elif (distances[0][0] >= 0 and distances[1][0] <= 0): new_fname_json[fname] = [distances[1][1], distances[0][1]] else: print abs(abs(distances[0][0]) - abs(distances[1][0])) return new_fname_json
def read_true_speed(relativepath, speed_recognizer): print 'Extracting true speed from {}'.format(relativepath) filenames = io_util.load_fnames(relativepath) output_dict = {} for fname in filenames: img = cv2.imread(os.path.join(relativepath, fname)) gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) curr_speed = speedrec.predict(gray_img) output_dict[fname] = curr_speed return output_dict
def ObjectTracker_Test(pic_dir): # Read the filenames from the list.txt file filenames = io_util.load_fnames(pic_dir) init_frame = 15 confidence_thresh = 7 filenames = io_util.load_fnames(pic_dir)[init_frame:init_frame + 50] ftmp1 = cv2.imread(os.path.join(pic_dir, filenames[init_frame]), cv2.IMREAD_GRAYSCALE).astype('uint8') # Top car left = 295 right = 335 top = 225 bot = 265 # Alternatively, track the side car # left = 440 # right = 550 # top = 205 # bot = 305 tracker = ObjectTracker.dlib_ObjectTracker(ftmp1, [left, top, right, bot]) [x1, y1, x2, y2] = tracker.get_position().astype(np.int64) cv2.rectangle(ftmp1, (x1, y1), (x2, y2), color=(255, 0, 0)) cv2.imshow('img', ftmp1) cv2.waitKey(1) for i in xrange(init_frame, len(filenames)): display.show_progressbar(i, filenames) ftmp = cv2.imread(os.path.join(pic_dir, filenames[i]), cv2.IMREAD_GRAYSCALE).astype('uint8') value = tracker.update(ftmp) [x1, y1, x2, y2] = tracker.get_position().astype(np.int64) cv2.rectangle(ftmp, (x1, y1), (x2, y2), color=(255, 0, 0)) cv2.imshow('img', ftmp) if value < confidence_thresh: print '\n\tlost object' break else: cv2.waitKey(1) print "" cv2.destroyAllWindows()
def get_vps(relativepath, boxes_fn): lanewidth = 5 filenames = io_util.load_fnames(relativepath) init_img = cv2.imread(os.path.join(relativepath, filenames[0]), cv2.IMREAD_GRAYSCALE).astype('uint8') lanemarker = LaneMarker.NietoLaneMarker() vpEstimator = VPEstimator.MSAC_LS(init_img.shape) boxes_dict = io_util.load_json(relativepath, boxes_fn) data = [] for i in range(len(filenames)): fname = filenames[i] display.show_progressbar(i, filenames) color_img = cv2.imread(os.path.join(relativepath, filenames[i])) gray_img = cv2.cvtColor(color_img, cv2.COLOR_BGR2GRAY).astype('uint8') # block region of the image - top, text, and vehicles blockedimg = image_util.blockTopImage(gray_img, 0.6) #cv2.imshow('block',blockedimg.astype('uint8')) image_util.block_EBRON(blockedimg) if fname in boxes_dict: for box_dict in boxes_dict[fname]: [x1, y1, x2, y2] = box_dict['box'] blockedimg[y1:y2, x1:x2] = 0 color_img[y1:y2, x1:x2] = 0 threshimg = image_util.thresholdImage(lanemarker.detect(blockedimg, lanewidth)) lines = cv2.HoughLines(threshimg, 1, cv2.cv.CV_PI/180, 30) if lines is None: continue linesegments = VPEstimator.preprocess_lines(lines[0]) if len(linesegments) < 5: continue vps, lineSegmentsClusters, numInliers = vpEstimator.multipleVPEstimation(linesegments, 1) for line in linesegments: [x1, y1, x2, y2] = line cv2.line(threshimg, (int(x1), int(y1)), (int(x2), int(y2)), (255, 255, 255), 1) cv2.line(color_img, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 1) if vps is not None: x, y = vps[0][0][0], vps[0][1][0] cv2.circle(color_img, (int(x), int(y)), 5, (255, 0, 0), thickness=3) cv2.circle(threshimg, (int(x), int(y)), 5, (255, 255, 255),thickness=3) data.append([x, y]) cv2.imshow('color image', color_img) #cv2.imshow('thresh image', threshimg) cv2.waitKey(1pospost) #break print "" cv2.destroyAllWindows() return np.array(data)
def LineTracker_Test(pic_dir, ipm, laneMarker, laneDetector, init_line=None): # Read the filenames from the list.txt file filenames = io_util.load_fnames(pic_dir) ftmp1 = cv2.imread(os.path.join(pic_dir, filenames[0]), cv2.IMREAD_GRAYSCALE).astype('uint8') if init_line is None: init_line = image_util.Line(274, 281, 125, 399) x1, y1 = ipm.pointToIPM((init_line.x1, init_line.y1)) x2, y2 = ipm.pointToIPM((init_line.x2, init_line.y2)) ipm_line = image_util.Line(x1, y1, x2, y2) tracker = LaneDetector.LineTracker(ipm_line, ftmp1.shape) display.draw_lines(ftmp1, [init_line]) cv2.imshow('img', ftmp1) for i in range(len(filenames)): print '\r{}'.format(filenames[i]), ftmp = cv2.imread(os.path.join(pic_dir, filenames[i]), cv2.IMREAD_GRAYSCALE).astype('float') ipm_img = ipm.imageToIPM(ftmp) lanemarker_img = laneMarker.detect(ipm_img, 5) threshold_img = image_util.thresholdImage(lanemarker_img, 95) # cv2.imshow('ipm', ipm_img.astype('uint8')) # cv2.imshow('lanemarker', lanemarker_img.astype('uint8')) # cv2.imshow('threshold_img', threshold_img.astype('uint8')) lane = tracker.update(threshold_img, laneDetector) if lane is not None: xns, yns = convertIPMLaneToLane(lane, ipm) pt1 = (int(xns[0]), int(yns[0])) pt2 = (int(xns[-1]), int(yns[-1])) cv2.line(ftmp, pt1, pt2, (255, 0, 0), 5) cv2.imshow('img', ftmp.astype('uint8')) cv2.waitKey(15) else: break print "" cv2.destroyAllWindows()
def lane_detection_validation(relativepath, test_lanes_fn, true_lanes_fn='manual_lanes.json', stepsize=15, vp_fn='vp.json'): print 'Lane Detection Validation for {}'.format(relativepath) filenames = io_util.load_fnames(relativepath) test_dict = io_util.load_json(relativepath, test_lanes_fn) hand_dict = io_util.load_json(relativepath, true_lanes_fn) vp_dict = io_util.load_json(relativepath, vp_fn) vp = vp_dict['vp'] true_positives = 0. false_positives = 0. false_negatives = 0. for fname in filenames[::stepsize]: hand_lanes = [] if fname in hand_dict: for line in hand_dict[fname]: [x1, y1] = line[0] [x2, y2] = line[1] hand_lanes.append(image_util.Line(x1, y1, x2, y2)) test_lanes = [] if fname in test_dict: for line in test_dict[fname]: [x1, y1] = line[0] [x2, y2] = line[1] test_lanes.append(image_util.Line(x1, y1, x2, y2)) test_lanes = remove_duplicates(test_lanes) #hand_lanes = get_nearby_lanes(hand_lanes, vp) #test_lanes = get_nearby_lanes(test_lanes, vp) img = cv2.imread(os.path.join(relativepath, fname)) display.draw_lines(img, hand_lanes, (255, 0, 0)) display.draw_lines(img, test_lanes, (0, 0, 255)) cv2.imshow('orig', img) for test_line in test_lanes[:]: for hand_line in hand_lanes[:]: if lines_close_enough(test_line, hand_line): hand_lanes.remove(hand_line) test_lanes.remove(test_line) true_positives += 1 break false_positives += len(test_lanes) false_negatives += len(hand_lanes) if len(test_lanes) > 0: img = cv2.imread(os.path.join(relativepath, fname)) # hand_lanes = [] # if fname in hand_dict: # for line in hand_dict[fname]: # [x1, y1] = line[0] # [x2, y2] = line[1] # hand_lanes.append(image_util.Line(x1, y1, x2, y2)) # test_lanes = [] # if fname in test_dict: # for line in test_dict[fname]: # [x1, y1] = line[0] # [x2, y2] = line[1] # test_lanes.append(image_util.Line(x1, y1, x2, y2)) display.draw_lines(img, hand_lanes, (255, 0, 0)) display.draw_lines(img, test_lanes, (0, 0, 255)) cv2.imshow('FP - truth is blue, red is code', img) # angle_diff = abs(hand_lanes[0].getAngle() - test_lanes[0].getAngle())/90. # print angle_diff*90. # intercept_diff = abs(hand_lanes[0].getIntercept() - test_lanes[0].getIntercept()) # print intercept_diff #print 'FP ', for i in range(len(test_lanes)): print fname, test_lanes[i].x1, test_lanes[i].y1, test_lanes[ i].x2, test_lanes[i].y2 cv2.waitKey(0) if len(hand_lanes) > 0: #print 'FN ', #for i in range(len(hand_lanes)): # print fname, hand_lanes[i].x1, hand_lanes[i].y1, hand_lanes[i].x2, hand_lanes[i].y2 img = cv2.imread(os.path.join(relativepath, fname)) display.draw_lines(img, hand_lanes, (255, 0, 0)) display.draw_lines(img, test_lanes, (0, 0, 255)) cv2.imshow('FN - truth is blue, red is code', img) cv2.waitKey(0) precision = 0 recall = 0 f1 = 0 if true_positives != 0: precision = true_positives / (true_positives + false_positives) recall = true_positives / (true_positives + false_negatives) f1 = 2 * (precision * recall) / (precision + recall) print '\tPrecision: {} ({}/{})'.format(precision, true_positives, (true_positives + false_positives)) print '\tRecall: {} ({}/{})'.format(recall, true_positives, (true_positives + false_negatives)) print '\tF1 Score: {}'.format(f1) return true_positives, false_positives, false_negatives
def filter_speed(relativepath, speed_fn, plot=True, dt=1 / 15.): print 'Starting filter analysis on {} for {}'.format( relativepath, speed_fn) filenames = io_util.load_fnames(relativepath) true_speed_dict = io_util.load_json(relativepath, 'true_speed.json') #true_speed_dict = io_util.load_json(relativepath, 'speed_readings.json') raw = io_util.load_json(relativepath, speed_fn) init_speed_est = 75 # in mph max_acc = 3.5 # in meters per sec names = ['AccLimit', 'KF'] filters = [ Filters.AccLimitFilter(init_speed_est, max_acc), Filters.KalmanFilter(np.array([[init_speed_est], [0]]), np.array([[1, 0], [0, 1]]), np.array([[1, 0], [0, 1]])) ] est_speeds = [[], []] true_speed = [] obv_speed = [] cp = [] mask = [] acclimit_dict = {} for fname in filenames: i = 0 obv = None if fname in raw: obv = raw[fname] for flter in filters: flter.predict(dt) if obv and not np.isinf(obv): flter.update(obv, dt) est = flter.get_estimate() if isinstance(est, np.ndarray): est = est[0] est_speeds[i].append(est) if names[i] == 'AccLimit': acclimit_dict[fname] = est i += 1 if obv: cp.append(obv) mask.append(1) else: cp.append(init_speed_est) mask.append(0) obv_speed.append(obv) true_speed.append(true_speed_dict[fname]) mask = np.array(mask) names.append('Butter LPF') names.append('Median Filter') names.append('Baseline') perc_obv = 1 - np.count_nonzero(np.equal(np.array(obv_speed), None)) / float(len(obv_speed)) print '\t% video w/ est {}'.format(perc_obv) if perc_obv < 0.5: return None est_speeds.append(Filters.butter_lpf(cp, cutoff=1, fs=15, order=6)) est_speeds.append(Filters.median_filter(cp)) est_speeds.append(np.array(cp)) ret = [] der = [] for i in range(len(names) - 1, -1, -1): name = names[i] est_arr = np.array(est_speeds[i]) true_arr = np.array(true_speed) l1_diff = np.abs(est_arr[np.where(mask == 1)] - true_arr[np.where(mask == 1)]) derivative_est = savgol_filter(est_arr, window_length=31, polyorder=2, deriv=1) derivative_true = savgol_filter(true_arr, window_length=31, polyorder=2, deriv=1) deriv_diff = np.abs(derivative_est[np.where(mask == 1)] - derivative_true[np.where(mask == 1)]) # plt.figure(1) # plt.title('Using Automatic Markings') # plt.plot(np.arange(len(obv_speed)), obv_speed, label='Raw Est Speed', color='g') # plt.plot(np.arange(len(true_speed)), true_speed, label='True Speed', color='b') # plt.plot(np.arange(len(est_speeds[i])), est_speeds[i], label=names[i], color='r') # plt.legend(loc='lower right') # plt.ylim([20, 120]) # plt.ylabel('Speed (MPH)') # plt.xlabel('Frame') # plt.show() # plt.figure(1) # plt.title('Using Automatic Markings') # plt.plot(np.arange(derivative_est.shape[0]), derivative_est, color='r', label=names[i]) # plt.plot(np.arange(derivative_true.shape[0]), derivative_true, color='b', label='True speed') # plt.legend(loc='lower right') # plt.ylim([-0.5, 0.5]) # plt.ylabel('Acceleration (MPH per second)') # plt.xlabel('Frame') # plt.show() print '\t' + name, print 'L1 Diff mean {}, std {}'.format(np.mean(l1_diff), np.std(l1_diff)) print 'Derivative Diff mean {}, std {}'.format(np.mean(deriv_diff), np.std(deriv_diff)) ret.append(l1_diff) der.append(deriv_diff) # if plot: # plt.figure(1) # plt.plot(np.arange(len(true_speed)), true_speed, label='True Speed') # plt.plot(np.arange(len(obv_speed)), obv_speed, label='Raw Est Speed') # for i in range(len(names)): # plt.plot(np.arange(len(est_speeds[i])), est_speeds[i], label=names[i]) # plt.legend(loc='lower right') # plt.ylim([0, 120]) # plt.show() return (ret, perc_obv, der, acclimit_dict)
def vehicle_detection_validation(full_path, detector_filepath, min_area=None, stepsize=15): print 'Starting vehicle detection validation test for {} using {}'.format( full_path, detector_filepath) filenames = io_util.load_fnames(full_path) detector_fn = detector_filepath.split('/')[-1].split('.svm')[0] test_dict_fn = 'boxes_output_{}_8.5.json'.format(detector_fn) #test_dict_fn = 'boxes_output_{}_8.5_run2.json'.format(detector_fn) test_dict = io_util.load_json(full_path, test_dict_fn) #test_dict = io_util.load_vehicle_boxes(full_path, use_hand_labeled=False) hand_dict = io_util.load_vehicle_boxes(full_path, use_hand_labeled=True) true_positives = 0. false_positives = 0. false_negatives = 0. for fname in filenames[::stepsize]: hand_boxes = [] if fname in hand_dict: hand_boxes = hand_dict[fname][:] test_boxes = [] if fname in test_dict: test_boxes = test_dict[fname] if min_area: for test_boxdict in test_boxes[:]: test_box = test_boxdict['box'] if image_util.compute_area(test_box) < min_area: test_boxes.remove(test_boxdict) for hand_box in hand_boxes[:]: if image_util.compute_area(hand_box) < min_area: hand_boxes.remove(hand_box) img1 = cv2.imread(os.path.join(full_path, fname)) display.draw_boxes(img1, hand_boxes) display.draw_boxdicts(img1, test_boxes, (0, 255, 0)) cv2.imshow('original', img1) test_boxes = remove_overlapping(test_boxes, full_path, fname) for test_boxdict in test_boxes[:]: test_box = test_boxdict['box'] for hand_box in hand_boxes[:]: if boxes_close_enough(test_box, hand_box): hand_boxes.remove(hand_box) test_boxes.remove(test_boxdict) true_positives += 1 break false_positives += len(test_boxes) false_negatives += len(hand_boxes) if len(hand_boxes) > 0: # hand_boxes = [] # if fname in hand_dict: # hand_boxes = hand_dict[fname] # test_boxes = [] # if fname in test_dict: # test_boxes = test_dict[fname] img1 = cv2.imread(os.path.join(full_path, fname)) # display.draw_boxes(img1, hand_boxes) # display.draw_boxdicts(img1, test_boxes, (0,0,255)) # cv2.imshow('FN - truth is blue, red is code', img1) # while True: # if cv2.waitKey(1) & 0xFF == ord('s'): # cv2.imwrite(os.path.join(full_path, 'fn_{}'.format(fname)), img1) # break # elif cv2.waitKey(1) & 0xFF == ord(' '): # break if len(test_boxes) > 0: # hand_boxes = [] # if fname in hand_dict: # hand_boxes = hand_dict[fname] # test_boxes = [] # if fname in test_dict: # test_boxes = test_dict[fname] img1 = cv2.imread(os.path.join(full_path, fname)) display.draw_boxes(img1, hand_boxes) display.draw_boxdicts(img1, test_boxes, (0, 0, 255)) # for box in test_boxes: # [x1, y1, x2, y2] = box['box'] # width = x2 - x1 # height = y2 - y1 # print '{},{},{},{},{},{},{}'.format(x1 + width/2., y1 + height/2., x1, y1, width, height,fname) cv2.imshow('FP - truth is blue, red is code', img1) cv2.waitKey(0) # while True: # if cv2.waitKey(1) & 0xFF == ord('s'): # cv2.imwrite(os.path.join(full_path, 'fp_{}'.format(fname)), img1) # break # elif cv2.waitKey(1) & 0xFF == ord(' '): # break precision = 0 recall = 0 f1 = 0 if true_positives != 0: precision = true_positives / (true_positives + false_positives) recall = true_positives / (true_positives + false_negatives) f1 = 2 * (precision * recall) / (precision + recall) print '\tPrecision: {} ({}/{})'.format(precision, true_positives, (true_positives + false_positives)) print '\tRecall: {} ({}/{})'.format(recall, true_positives, (true_positives + false_negatives)) print '\tF1 Score: {}'.format(f1) return true_positives, false_positives, false_negatives
def following_main(relativepath, lanes_fn='nearby_lanes.json', spd_fn='speed_acclimit.json', vp_fn='vp.json', boxes_fn='boxes_output_detector_session2_raw_8.5.json', cv_display=True): filenames = io_util.load_fnames(relativepath) fname_lanes_dict = io_util.load_json(relativepath, lanes_fn) vp_dict = io_util.load_json(relativepath, vp_fn) vp = vp_dict['vp'] fname_boxes_dict = io_util.load_json(relativepath, boxes_fn) speed_dict = io_util.load_json(relativepath, spd_fn) initimg = cv2.imread(os.path.join(relativepath, filenames[0]), cv2.IMREAD_GRAYSCALE) imgshape = initimg.shape imgheight, imgwidth = imgshape origPts, destPts = image_util.locateROI(imgshape, x_frac=1/10., y_frac_top=1/60., y_frac_bot=1/6., vp=vp) for ii in xrange(len(origPts)): if ii == (len(origPts) - 1): cv2.line(initimg, tuple(origPts[ii]), tuple(origPts[0]), (255, 255, 255), 2) else: cv2.line(initimg, tuple(origPts[ii]), tuple(origPts[ii+1]), (255, 255, 255), 2) cv2.imshow('initimg', initimg) cv2.waitKey(0) ipm = IPM.IPM(imgshape, imgshape, origPts, destPts) lanemarker = LaneMarker.NietoLaneMarker() follow_dict = {} for i in range(len(filenames)): fname = filenames[i] display.show_progressbar(i, filenames) if fname in fname_lanes_dict: img = cv2.imread(os.path.join(relativepath, fname)) gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY).astype('float') image_util.block_EBRON(gray_img) new_pts = [] if fname in fname_boxes_dict: box_dicts = fname_boxes_dict[fname] for box_dict in box_dicts: x1, y1, x2, y2 = np.array(box_dict['box']).astype(np.int64) gray_img[y1:y2,x1:x2] = 0 bottom_center = [(x1 + x2)/2., y2] new_pt = ipm.pointToIPM(bottom_center) new_pts.append(new_pt) ipm_img = ipm.imageToIPM(gray_img) tmp = cv2.cvtColor(ipm_img.astype('uint8').copy(), cv2.COLOR_GRAY2BGR) lanes = fname_lanes_dict[fname] lines = [] for lane in lanes: [x1, y1] = ipm.pointToIPM(lane[0]) [x2, y2] = ipm.pointToIPM(lane[1]) lines.append(image_util.Line(x1, y1, x2, y2)) slope, b = computeXLineDifferences(lines[0], lines[1]) for new_pt in new_pts: [x, y] = new_pt if (x > lines[0].x1 and x > lines[0].x2 and x < lines[1].x1 and x < lines[1].x2 and y < imgshape[0] and y > 0): cv2.circle(tmp, (int(x), int(y)), 5, (255, 0, 0), thickness=3) conversion = 12./(slope * y + b) distance = conversion*(imgshape[0] - y) #print distance follow_dict[fname] = {'distance': distance, 'speed':speed_dict[fname]} display.draw_lines(tmp, lines, color=(0, 255, 0)) if cv_display: cv2.imshow('Tmp', tmp) cv2.waitKey(1) print "" cv2.destroyAllWindows() io_util.save_json(relativepath, 'follow_distance_speed.json', follow_dict) print 'Done'
def svm_detection_validation(full_path, detector_filepath, min_area=None, load_boxes=False, stepsize=15): print 'Starting svm validation test for {}'.format(full_path) filenames = io_util.load_fnames(full_path) hand_dict = io_util.load_vehicle_boxes(full_path, use_hand_labeled=True) true_positives = 0. false_positives = 0. false_negatives = 0. detector_fn = detector_filepath.split('/')[-1].split('.svm')[0] if min_area: test_dict_fn = 'boxes_{}.json'.format(detector_fn) else: test_dict_fn = 'boxes_nominarea_{}.json'.format(detector_fn) test_dict = {} if load_boxes: test_dict = io_util.load_json(full_path, test_dict_fn) else: dlib_detector = dlib.simple_object_detector(detector_filepath) for fname in filenames[::stepsize]: if fname not in hand_dict: continue hand_boxes = hand_dict[fname] test_boxes = [] if load_boxes: test_boxes = test_dict[fname] else: img = cv2.imread(os.path.join(full_path, fname)) found_list = dlib_detector(img) for dlib_rect in found_list: test_boxes.append(convert_dlib_rect(dlib_rect)) test_dict[fname] = np.array(test_boxes) if min_area: for test_box in test_boxes[:]: if image_util.compute_area(test_box) < min_area: test_boxes.remove(test_box) for hand_box in hand_boxes[:]: if image_util.compute_area(hand_box) < min_area: hand_boxes.remove(hand_box) for test_box in test_boxes[:]: for hand_box in hand_boxes[:]: if boxes_close_enough(test_box, hand_box): hand_boxes.remove(hand_box) test_boxes.remove(test_box) true_positives += 1 break false_positives += len(test_boxes) false_negatives += len(hand_boxes) if not load_boxes: io_util.save_json(full_path, test_dict_fn, test_dict) precision = 0 recall = 0 if true_positives != 0: precision = true_positives / (true_positives + false_positives) recall = true_positives / (true_positives + false_negatives) print '\tPrecision: {} ({}/{})'.format(precision, true_positives, (true_positives + false_positives)) print '\tRecall: {} ({}/{})'.format(recall, true_positives, (true_positives + false_negatives)) return true_positives, false_positives, false_negatives
def speed_estimation_main( relativepath, uniform_conversion=False, lanes_fn='nearby_lanes.json', true_spd_fn='true_speed.json', vp_fn='vp.json', boxes_fn='boxes_output_detector_session2_raw_8.5.json'): print 'Starting speed estimation for {}'.format(relativepath) filenames = io_util.load_fnames(relativepath) fname_lanes_dict = io_util.load_json(relativepath, lanes_fn) vp_dict = io_util.load_json(relativepath, vp_fn) vp = vp_dict['vp'] fname_boxes_dict = io_util.load_json(relativepath, boxes_fn) initimg = cv2.imread(os.path.join(relativepath, filenames[0]), cv2.IMREAD_GRAYSCALE) imgshape = initimg.shape imgheight, imgwidth = imgshape origPts, destPts = image_util.locateROI(imgshape, x_frac=1 / 3., y_frac_top=1 / 25., y_frac_bot=1 / 6., vp=vp) ipm = IPM.IPM(imgshape, imgshape, origPts, destPts) lanemarker = LaneMarker.NietoLaneMarker() if uniform_conversion: slopes = [] bs = [] for fname in filenames: if fname in fname_lanes_dict: lanes = fname_lanes_dict[fname] lines = [] for lane in lanes: [x1, y1] = ipm.pointToIPM(lane[0]) [x2, y2] = ipm.pointToIPM(lane[1]) lines.append(image_util.Line(x1, y1, x2, y2)) slope, b = computeXLineDifferences(lines[0], lines[1]) slopes.append(slope) bs.append(b) mean_slope = np.mean(np.array(slopes)) mean_b = np.mean(np.array(bs)) speed_detector = SpeedEstimator.Lane_SpeedEstimator( lanemarker, mean_slope, mean_b) else: speed_detector = SpeedEstimator.Lane_SpeedEstimator(lanemarker) output_left = {} output_right = {} for i in range(len(filenames)): fname = filenames[i] display.show_progressbar(i, filenames) if fname in fname_lanes_dict: img = cv2.imread(os.path.join(relativepath, fname)) gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY).astype('float') image_util.block_EBRON(gray_img) if fname in fname_boxes_dict: box_dicts = fname_boxes_dict[fname] for box_dict in box_dicts: x1, y1, x2, y2 = np.array(box_dict['box']).astype(np.int64) gray_img[y1:y2, x1:x2] = 0 ipm_img = ipm.imageToIPM(gray_img) tmp = cv2.cvtColor( ipm_img.astype('uint8').copy(), cv2.COLOR_GRAY2BGR) lanes = fname_lanes_dict[fname] lines = [] for lane in lanes: [x1, y1] = ipm.pointToIPM(lane[0]) [x2, y2] = ipm.pointToIPM(lane[1]) lines.append(image_util.Line(x1, y1, x2, y2)) display.draw_lines(tmp, lines, color=(0, 255, 0)) cv2.imshow('Tmp', tmp) cv2.waitKey(0) speed_est_L, speed_est_R = speed_detector.update( ipm_img, lines[0], lines[1]) output_left[fname] = speed_est_L output_right[fname] = speed_est_R print "" if uniform_conversion: io_util.save_json(relativepath, 'speed_raw_left_uni.json', output_left) io_util.save_json(relativepath, 'speed_raw_right_uni.json', output_right) else: io_util.save_json(relativepath, 'speed_raw_left.json', output_left) io_util.save_json(relativepath, 'speed_raw_right.json', output_right)
default='../Videos/Dashcam/PCH') ap.add_argument('-vp', '--vanishingpoint', help="VP as X,Y", default="309.74,242.14") args = ap.parse_args() relativepath = args.videopath tmp = args.vanishingpoint.split(',') vpx = float(tmp[0]) vpy = float(tmp[1]) vp = [vpx, vpy] run_LineTracker_Test = False run_LaneDetector_Test = True filenames = io_util.load_fnames(relativepath) initimg = cv2.imread(os.path.join(relativepath, filenames[0]), cv2.IMREAD_GRAYSCALE).astype('uint8') laneMarker = LaneMarker.NietoLaneMarker() laneDetector = LaneDetector.PolyRANSAC_LaneDetector(verbose=False) laneDetectorModel = LaneDetector.LaneDetectorModel([], initimg.shape, laneDetector) origPts, destPts = image_util.locateROI(initimg.shape, x_frac=1 / 3., y_frac_top=1 / 12., y_frac_bot=1 / 6., vp=vp) show_roi = False
def visualize_lane_changes(relativepath): lanes_fn = 'nearby_lanes.json' vp_fn = 'vp.json' filenames = io_util.load_fnames(relativepath) fname_lanes_dict = io_util.load_json(relativepath, lanes_fn) vp_dict = io_util.load_json(relativepath, vp_fn) vp = vp_dict['vp'] initimg = cv2.imread(os.path.join(relativepath, filenames[0]), cv2.IMREAD_GRAYSCALE) imgshape = initimg.shape imgheight, imgwidth = imgshape origPts, destPts = image_util.locateROI(imgshape, x_frac=1 / 3., y_frac_top=1 / 25., y_frac_bot=1 / 6., vp=vp) ipm = IPM.IPM(imgshape, imgshape, origPts, destPts) lpts = [] rpts = [] for i in range(0, 900): fname = filenames[i] if fname in fname_lanes_dict: lanes = fname_lanes_dict[fname] j = 0 for lane in lanes: [x1, y1] = ipm.pointToIPM(lane[0]) [x2, y2] = ipm.pointToIPM(lane[1]) if j == 0: lpts.append((x1 + x2) / 2.) j = 1 else: rpts.append((x1 + x2) / 2.) else: lpts.append(None) rpts.append(None) l = [] r = [] window_size = 1 for i in range(len(lpts)): if i < window_size: l.append(0) elif lpts[i] is None or lpts[i - window_size] is None: l.append(0) else: l.append(lpts[i] - lpts[i - window_size]) l = np.array(l) for i in range(len(rpts)): if i < window_size: r.append(0) elif rpts[i] is None or rpts[i - window_size] is None: r.append(0) else: r.append(rpts[i] - rpts[i - window_size]) r = np.array(r) def movingaverage(values, window=15): weights = np.repeat(1.0, window) / window sma = np.convolve(values, weights, 'same') return sma plt.figure(1) #plt.scatter(np.arange(l.shape[0]), l, color='b', label='Raw',s=5) #plt.scatter(np.arange(l.shape[0]), movingaverage(l), color='r', label='Average',s=5) plt.plot(np.arange(l.shape[0]), (l + r) / 2, color='g', label='Raw') plt.plot(np.arange(l.shape[0]), movingaverage((l + r) / 2), color='r', label='Moving Average') plt.plot(np.arange(l.shape[0]), medfilt(movingaverage((l + r) / 2), 15), color='b', label='Median and Moving Average') plt.ylim([-5, 5]) plt.xlabel('Frame') plt.ylabel('$\Delta$x of Lane Boundaries (in pixels)') plt.legend(loc='lower left') plt.show()
def lane_detector_main(relativepath, boxes_fn, vp_fn, display_, verbose): # Read the filenames from the list.txt file filenames = io_util.load_fnames(relativepath) #filenames = filenames[700:] initimg = cv2.imread(os.path.join(relativepath, filenames[0]), cv2.IMREAD_GRAYSCALE) imgshape = initimg.shape imgheight, imgwidth = imgshape # Initialize the objects lanemarker = LaneMarker.NietoLaneMarker() laneDetector = LaneDetector.PolyRANSAC_LaneDetector(verbose=False) laneDetectorModel = LaneDetector.LaneDetectorModel([], imgshape, laneDetector) vp_dict = io_util.load_json(relativepath, vp_fn) vp = vp_dict['vp'] origPts, destPts = image_util.locateROI(imgshape, x_frac=1 / 3., y_frac_top=1 / 25., y_frac_bot=1 / 6., vp=vp) # for ii in xrange(len(origPts)): # if ii == (len(origPts) - 1): # cv2.line(initimg, tuple(origPts[ii]), tuple(origPts[0]), (255, 255, 255), 2) # else: # cv2.line(initimg, tuple(origPts[ii]), tuple(origPts[ii+1]), (255, 255, 255), 2) #cv2.imshow('initimg', initimg) #cv2.waitKey(0) if verbose: print 'Starting IPM' ipm = IPM.IPM(imgshape, imgshape, origPts, destPts) if verbose: print 'Done with IPM' # Dictionary where key = filename, # value = list of boxes of objects in that image fname_boxes_dict = io_util.load_json(relativepath, boxes_fn) fname_lanes_dict = {} # For each image for fi in range(len(filenames)): display.show_progressbar(fi, filenames) fname = filenames[fi] img = cv2.imread(os.path.join(relativepath, fname)) image_util.block_EBRON(img) gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY).astype('float') # Check for found vehicles in the image. For each one, zero out the # region where the vehicle has been found if fname in fname_boxes_dict: box_dicts = fname_boxes_dict[fname] for box_dict in box_dicts: x1, y1, x2, y2 = np.array(box_dict['box']).astype(np.int64) gray_img[y1:y2, x1:x2] = 0 if display_: cv2.rectangle(img, (x1, y1), (x2, y2), color=(255, 0, 0)) # Perform IPM, lane marking detection, and thresholding ipm_img = ipm.imageToIPM(gray_img) lanemarker_img = lanemarker.detect(ipm_img, 5) threshold_img = image_util.thresholdImage(lanemarker_img, 95) if display_ and verbose: cv2.imshow('IPMImage', ipm_img.astype('uint8')) cv2.imshow('LaneMarker Raw', lanemarker_img.astype('uint8')) cv2.imshow('laneMarker Thresholded', threshold_img.astype('uint8')) cv2.waitKey(1) # Update the lane detector model with the image to get the lanes degree = 1 lanes = laneDetectorModel.updateLaneModel(threshold_img, degree) # Save lanes for lane in lanes: xns, yns = convertIPMLaneToLane(lane, ipm) pt1 = (int(xns[0]), int(yns[0])) pt2 = (int(xns[-1]), int(yns[-1])) if display_: cv2.line(img, pt1, pt2, (255, 0, 0), 5) if fname in fname_lanes_dict: fname_lanes_dict[fname].append([pt1, pt2]) else: fname_lanes_dict[fname] = [[pt1, pt2]] # For new lanes, perform backward tracking with a LineTracker object # (same steps as above) new_lanes = laneDetectorModel.get_new_lanes() for new_lane in new_lanes: new_line = new_lane.asLine() # if verbose: # print '\t Starting backwards track' prev_lane_tracker = LaneDetector.LineTracker(new_line, imgshape) for fj in range(fi - 1, -1, -1): prev_fname = filenames[fj] prev_img = cv2.imread(os.path.join(relativepath, prev_fname)) image_util.block_EBRON(prev_img) prev_gray_img = cv2.cvtColor( prev_img, cv2.COLOR_BGR2GRAY).astype('float') if prev_fname in fname_boxes_dict: box_dicts = fname_boxes_dict[prev_fname] for box_dict in box_dicts: left, top, right, bot = box_dict['box'] prev_gray_img[top:bot, left:right] = 0 prev_ipm_img = ipm.imageToIPM(prev_gray_img) prev_lanemarker_img = lanemarker.detect(prev_ipm_img, 5) prev_threshold_img = image_util.thresholdImage( prev_lanemarker_img, 95) prev_lane = prev_lane_tracker.update(prev_threshold_img, laneDetector, degree) if prev_lane is None: #if verbose: # print '\t Breaking, no suitable backwards lane found' break else: xns, yns = convertIPMLaneToLane(prev_lane, ipm) pt1 = (int(xns[0]), int(yns[0])) pt2 = (int(xns[-1]), int(yns[-1])) if prev_fname not in fname_lanes_dict: fname_lanes_dict[prev_fname] = [[pt1, pt2]] else: # Backwards lane pruning. But note this compares lines # in the non-IPM space line = image_util.Lane(xns, yns).asLine() is_new_line = True for [ppt1, ppt2] in fname_lanes_dict[prev_fname]: prev_line = image_util.Line( ppt1[0], ppt1[1], ppt2[0], ppt2[1]) if line.checkLineIntersection(prev_line): is_new_line = False break if is_new_line: fname_lanes_dict[prev_fname].append([pt1, pt2]) else: # if verbose: # print '\t Breaking, intersected with previous lane' break #if verbose: # print '\t Ended backwards track at ' + filenames[fj] if display_: cv2.imshow('frame', img) cv2.waitKey(1) print "" output_fname = os.path.join(relativepath, 'lanes_output_new.json') with open(output_fname, 'w') as outfile: json.dump(fname_lanes_dict, outfile, indent=4, sort_keys=True) print 'Wrote json output file' cv2.destroyAllWindows()
def vehicle_detector_main(relativepath, display_frames, dlib_detector_fname, verbose, forward_confidence_thresh, backward_confidence_thresh, run_backwards_tracking=True): if verbose: print 'Starting vehicle detector main for {}'.format(relativepath) # # Read the filenames from the list.txt file filenames = io_util.load_fnames(relativepath) # Get the shape from the first image tmp_img = cv2.imread(os.path.join(relativepath, filenames[0]), cv2.IMREAD_GRAYSCALE) imgshape = tmp_img.shape imgheight, imgwidth = imgshape # Confidence value where if we fall below this, we stop backwards tracking confidence_threshold = forward_confidence_thresh previous_track_confidence = backward_confidence_thresh # Set up the vehicle detector object vehicleDetector = VehicleDetector.VehicleDetector( dlib_detector_fname, confidence_threshold, previous_track_confidence) # Output dictionary where key = filename, # value = list of boxes + ids of objects in that image fname_boxes_dict = {} for fi in range(len(filenames)): if verbose: display.show_progressbar(fi, filenames) fname = filenames[fi] img = cv2.imread(os.path.join(relativepath, fname), cv2.IMREAD_GRAYSCALE) # Add any detected boxes to the dictionary vehicle_boxes = vehicleDetector.update(img) if fname not in fname_boxes_dict: fname_boxes_dict[fname] = [] for box_dict in vehicle_boxes: fname_boxes_dict[fname].append(box_dict) # For new detected boxes, initialize an object tracker to go backwards # and detect boxes in previous frames, until the confidence falls below # a certain threshold new_box_dicts = vehicleDetector.get_new_boxes() if run_backwards_tracking: vehicleDetector.initialize_backwards(img) for fj in range(fi - 1, -1, -1): prev_fname = filenames[fj] prev_img = cv2.imread(os.path.join(relativepath, prev_fname), cv2.IMREAD_GRAYSCALE) boxes = vehicleDetector.update_backwards(prev_img) if boxes is None: break else: if prev_fname in fname_boxes_dict: fname_boxes_dict[prev_fname] += boxes else: fname_boxes_dict[prev_fname] = boxes # for box_dict in new_box_dicts: # #if verbose: # # print '\n\t Starting backwards track' # new_box = box_dict['box'] # new_box_id = box_dict['id'] # new_object_tracker = ObjectTracker.dlib_ObjectTracker(img, new_box, # new_box_id, store_size=1) # for fj in range(fi - 1, -1, -1): # prev_fname = filenames[fj] # prev_img = cv2.imread(os.path.join(relativepath,prev_fname), # cv2.IMREAD_GRAYSCALE) # confidence = new_object_tracker.update(prev_img) # if confidence < previous_track_confidence: # break # else: # if prev_fname in fname_boxes_dict: # fname_boxes_dict[prev_fname].append( # new_object_tracker.get_dict()) # else: # fname_boxes_dict[prev_fname] = [ # new_object_tracker.get_dict()] # #if verbose: # # print '\t Ended backwards track at ' + filenames[fj] if verbose: print "" # Create the output json file of the boxes detector_fn = dlib_detector_fname.split('/')[-1].split('.svm')[0] output_fname = os.path.join( relativepath, 'boxes_output_{}_{}_run2.json'.format(detector_fn, confidence_threshold)) with open(output_fname, 'w') as outfile: json.dump(fname_boxes_dict, outfile, indent=4, sort_keys=True, cls=io_util.NumpyEncoder) # Display the images with the boxes and ids on them if display_frames: for fname in filenames: boxes = fname_boxes_dict[fname] img = cv2.imread(os.path.join(relativepath, fname)) display.draw_boxdicts(img, boxes, (255, 0, 0)) cv2.imshow('With box and id labels', img) cv2.waitKey(1) cv2.destroyAllWindows()