Exemplo n.º 1
0
def area_filtering_auc_vs_pixels(cf, background_img_list, foreground_img_list, foreground_gt_list):
    logger = logging.getLogger(__name__)

    mean_back, variance_back = background_modeling.multivariative_gaussian_modelling(
        background_img_list, cf.color_space
    )

    alpha_range = np.linspace(cf.evaluate_alpha_range[0], cf.evaluate_alpha_range[1], num=cf.evaluate_alpha_values)

    auc = []  # Store AUC values to plot
    pixels_range = np.linspace(cf.P_pixels_range[0], cf.P_pixels_range[1], num=cf.P_pixels_values)
    best_alphas = []
    for pixels in pixels_range:
        logger.info("Pixels P: " + str(pixels))

        precision = []
        recall = []
        f1_score = []
        logger.info('Iterating alpha from {} to {}, {} steps'.format(alpha_range[0], alpha_range[-1], len(alpha_range)))
        for alpha in alpha_range:
            tp = 0
            fp = 0
            tn = 0
            fn = 0
            mean = np.copy(mean_back)
            variance = np.copy(variance_back)

            for (image, gt) in zip(foreground_img_list, foreground_gt_list):
                gt_img = cv.imread(gt, cv.IMREAD_GRAYSCALE)
                foreground, mean, variance = background_modeling.adaptive_foreground_estimation_color(
                    image, mean, variance, alpha, cf.rho, cf.color_space
                )

                if cf.task_name == 'task3':

                    foreground = image_opening(foreground, cf.opening_strel, cf.opening_strel_size)

                    foreground = image_closing(foreground,  cf.closing_strel, cf.closing_strel_size)

                foreground = hole_filling(foreground, cf.four_connectivity)

                # Area Filtering
                foreground = remove_small_regions(foreground, pixels)
                foreground = np.array(foreground, dtype='uint8')
                tp_temp, fp_temp, tn_temp, fn_temp = segmentation.evaluate_single_image(foreground, gt_img)

                tp += tp_temp
                fp += fp_temp
                tn += tn_temp
                fn += fn_temp

            pre = tp / (tp + fp) if (tp + fp) > 0 else 0.0
            rec = tp / (tp + fn) if (tp + fn) > 0 else 0.0
            f1 = 2 * pre * rec / (pre + rec + EPSILON)

            precision.append(tp / (tp + fp) if (tp + fp) > 0 else 0.0)
            recall.append(tp / (tp + fn) if (tp + fn) > 0 else 0.0)
            f1_score.append(f1)
            logger.info('Alpha: {}. F1-score {} '.format(alpha, f1_score))
        best_f1_score = max(f1_score)
        index_alpha = f1_score.index(best_f1_score)
        best_alpha = alpha_range[index_alpha]
        best_precision = precision[index_alpha]
        best_recall = recall[index_alpha]
        best_alphas.append(best_alpha)

        try:
            auc_pr = metrics.auc(recall, precision, reorder=False)
        except ValueError:
            # Use reorder=True, even if it is not the correct way to compute the AUC for the PR curve
            auc_pr = metrics.auc(recall, precision, reorder=True)

        logger.info('Best alpha: {:.4f}'.format(best_alpha))
        logger.info('Best F1-score: {:.4f}'.format(best_f1_score))
        logger.info('Best precision: {:.4f}'.format(best_precision))
        logger.info('Best recall: {:.4f}'.format(best_recall))
        logger.info('AUC: {:.4f}'.format(auc_pr))
        auc.append(auc_pr)

    max_auc = max(auc)
    index_pixels = auc.index(max_auc)
    best_pixels = pixels_range[index_pixels]
    best_alpha = best_alphas[index_pixels]
    logger.info('Best AUC: {:.4f}'.format(max_auc))

    return auc, pixels_range, best_pixels, best_alpha
Exemplo n.º 2
0
def vehicle_tracker(cf):
    with log_context(cf.log_file):
        logger = logging.getLogger(__name__)
        logger.info(' ---> Init test: ' + cf.test_name + ' <---')

        if cf.save_results:
            logger.info('Saving results in {}'.format(cf.results_path))
            mkdirs(cf.results_path)

        image_list = get_image_list_changedetection_dataset(
            cf.dataset_path, 'in', cf.first_image, cf.image_type, cf.nr_images)

        background_img_list = image_list[:len(image_list) // 2]
        foreground_img_list = image_list[(len(image_list) // 2):]
        mean, variance = background_modeling.multivariative_gaussian_modelling(
            background_img_list, cf.color_space)

        # Instantiate tracker for multi-object tracking
        kalman_init_params = {
            'init_estimate_error': cf.init_estimate_error,
            'motion_model_noise': cf.motion_model_noise,
            'measurement_noise': cf.measurement_noise
        }
        multi_tracker = MultiTracker(cf.cost_of_non_assignment,
                                     cf.invisible_too_long,
                                     cf.min_age_threshold, kalman_init_params)

        for image_path in tqdm(foreground_img_list):

            foreground, mean, variance = background_modeling.adaptive_foreground_estimation_color(
                image_path, mean, variance, cf.alpha, cf.rho, cf.color_space)

            foreground = foreground_improving.hole_filling(
                foreground, cf.four_connectivity)
            foreground = foreground_improving.remove_small_regions(
                foreground, cf.area_filtering_P)
            foreground = foreground_improving.image_opening(
                foreground, cf.opening_strel, cf.opening_strel_size)
            foreground = foreground_improving.image_closing(
                foreground, cf.closing_strel, cf.closing_strel_size)

            image_gray = skio.imread(image_path, as_grey=True)
            bboxes, centroids = detection.detectObjects(image_gray, foreground)

            # Tracking
            multi_tracker.predict_new_locations_of_tracks()
            multi_tracker.detection_to_track_assignment(centroids)
            multi_tracker.update_assigned_tracks(bboxes, centroids)
            multi_tracker.update_unassigned_tracks()
            multi_tracker.delete_lost_tracks()
            multi_tracker.create_new_tracks(bboxes, centroids)

            if cf.save_results:
                image_name = os.path.basename(image_path)
                image_name = os.path.splitext(image_name)[0]
                save_path = os.path.join(
                    cf.results_path, image_name + '.' + cf.result_image_type)
                image = cv.imread(image_path)
                visualization.display_tracking_results(image,
                                                       multi_tracker.tracks,
                                                       foreground, save_path)

        logger.info(' ---> Finish test: ' + cf.test_name + ' <---')
Exemplo n.º 3
0
def visualize_all_tracks(cf):
    with log_context(cf.log_file):
        logger = logging.getLogger(__name__)
        logger.info(' ---> Init test: ' + cf.test_name + ' <---')

        if cf.save_results:
            logger.info('Saving results in {}'.format(cf.results_path))
            mkdirs(cf.results_path)

        image_list = get_image_list_changedetection_dataset(
            cf.dataset_path, 'in', cf.first_image, cf.image_type, cf.nr_images)

        background_img_list = image_list[:len(image_list) // 2]
        foreground_img_list = image_list[(len(image_list) // 2):]
        mean, variance = background_modeling.multivariative_gaussian_modelling(
            background_img_list, cf.color_space)

        # Instantiate tracker for multi-object tracking
        #tracker = Tracker(cf.distance_threshold, cf.max_frames_to_skip, cf.max_trace_length, 0, cf)

        tracks = []  # Create an empty array of tracks.

        nextId = 1  # ID of the next track

        for image_path in foreground_img_list:

            foreground, mean, variance = background_modeling.adaptive_foreground_estimation_color(
                image_path, mean, variance, cf.alpha, cf.rho, cf.color_space)

            foreground = foreground_improving.hole_filling(
                foreground, cf.four_connectivity)
            foreground = foreground_improving.remove_small_regions(
                foreground, cf.area_filtering_P)
            foreground = foreground_improving.image_opening(
                foreground, cf.opening_strel, cf.opening_strel_size)
            foreground = foreground_improving.image_closing(
                foreground, cf.closing_strel, cf.closing_strel_size)

            bboxes, centroids = detection.detectObjects(image_path, foreground)
            multi_tracking.predictNewLocationsOfTracks(tracks)
            assignments, unassignedTracks, unassignedDetections = multi_tracking.detectionToTrackAssignment(
                tracks, centroids, cf.costOfNonAssignment)
            multi_tracking.updateAssignedTracks(tracks, bboxes, centroids,
                                                assignments)
            multi_tracking.updateUnassignedTracks(tracks, unassignedTracks)
            multi_tracking.createNewTracks(tracks, bboxes, centroids,
                                           unassignedDetections)

        img = cv.imread(
            cf.dataset_path +
            '/in000023.jpg')  # in000023 for traffic and in000471 for highway
        if tracks != list():

            # Display the objects. If an object has not been detected
            # in this frame, display its predicted bounding box.
            if tracks != list():
                for track in tracks:
                    car_colour = CAR_COLOURS[track.id % len(CAR_COLOURS)]
                    # for point in track.positions:
                    #    cv.circle(img, (int(point[0]), int(point[1])), 5, car_colour, 1)
                    cv.polylines(img, [np.int32(track.positions)], False,
                                 (0, 0, 0), 1)
                    '''for point in track.predictions:
                        vrtx = np.array([[point[0]-5, point[1]-5], [point[0], point[1]+5], [point[0]+5, point[1]-5]],
                                        np.int32)
                        cv.polylines(img, [vrtx], True, car_colour, 1)
                        # cv.rectangle(img, (int(point[0]) - 2, int(point[1]) - 2),
                        #            (int(point[0]) + 2, int(point[1]) + 2), car_colour, 1)'''
                    cv.polylines(img, [np.int32(track.predictions)], False,
                                 car_colour, 1)

        cv.imwrite(cf.results_path + '/all_tracks.jpg', img)
        logger.info(' ---> Finish test: ' + cf.test_name + ' <---')
Exemplo n.º 4
0
def foreground_estimation(cf):

    if cf.AUC_area_filtering:
        """ TASK 2 """

        with log_context(cf.log_file):

            # Get a list with input images filenames
            image_list = get_image_list_changedetection_dataset(
                cf.dataset_path, 'in', cf.first_image, cf.image_type, cf.nr_images
            )

            # Get a list with groung truth images filenames
            gt_list = get_image_list_changedetection_dataset(
                cf.gt_path, 'gt', cf.first_image, cf.gt_image_type, cf.nr_images
            )
            background_img_list = image_list[:len(image_list) // 2]
            foreground_img_list = image_list[(len(image_list) // 2):]
            foreground_gt_list = gt_list[(len(image_list) // 2):]

            auc_pr, pixels_range, best_pixels, best_alpha = foreground_improving.area_filtering_auc_vs_pixels(
                cf, background_img_list, foreground_img_list, foreground_gt_list
            )

            visualization.aux_plot_auc_vs_pixels(auc_pr, pixels_range, cf.output_folder)

            # Save auc_pr as a pickle
            auc_pr_path = os.path.join(cf.output_folder, '{}_AUC_vs_pixels.pkl'.format(cf.dataset_name))
            with open(auc_pr_path, 'w') as fd:
                pickle.dump(auc_pr, fd)

            if cf.save_results:
                mkdirs(cf.results_path)
                mean, variance = background_modeling.multivariative_gaussian_modelling(background_img_list,
                                                                                       cf.color_space)
                for (image, gt) in zip(foreground_img_list, foreground_gt_list):
                    foreground, mean, variance = background_modeling.adaptive_foreground_estimation_color(
                        image, mean, variance, best_alpha, cf.rho, cf.color_space
                    )
                    foreground = foreground_improving.hole_filling(foreground, cf.four_connectivity)
                    foreground = foreground_improving.remove_small_regions(foreground, best_pixels)
                    fore = np.array(foreground, dtype='uint8') * 255
                    image_name = os.path.basename(image)
                    image_name = os.path.splitext(image_name)[0]
                    cv.imwrite(
                        os.path.join(cf.results_path, 'task2_' + image_name + '.' + cf.result_image_type),
                        fore)

    else:
        with log_context(cf.log_file):
            logger = logging.getLogger(__name__)

            # Get a list with input images filenames
            image_list = get_image_list_changedetection_dataset(
                cf.dataset_path, 'in', cf.first_image, cf.image_type, cf.nr_images
            )

            # Get a list with groung truth images filenames
            gt_list = get_image_list_changedetection_dataset(
                cf.gt_path, 'gt', cf.first_image, cf.gt_image_type, cf.nr_images
            )
            background_img_list = image_list[:len(image_list) // 2]
            foreground_img_list = image_list[(len(image_list) // 2):]
            foreground_gt_list = gt_list[(len(image_list) // 2):]

            # Task 1
            mean_back, variance_back = background_modeling.multivariative_gaussian_modelling(background_img_list,
                                                                                   cf.color_space)

            alpha_range = np.linspace(cf.evaluate_alpha_range[0], cf.evaluate_alpha_range[1], num=cf.evaluate_alpha_values)

            precision = []
            recall = []
            F1_score = []
            i = 1
            for alpha in alpha_range:

                tp = 0
                fp = 0
                tn = 0
                fn = 0
                mean = np.copy(mean_back)
                variance = np.copy(variance_back)

                for (image, gt) in zip(foreground_img_list, foreground_gt_list):
                    gt_img = cv.imread(gt, cv.IMREAD_GRAYSCALE)
                    foreground, mean, variance = background_modeling.adaptive_foreground_estimation_color(
                        image, mean, variance, alpha, cf.rho, cf.color_space
                    )

                    foreground = foreground_improving.hole_filling(foreground, cf.four_connectivity)

                    if cf.area_filtering:
                        # Area Filtering
                        foreground = foreground_improving.remove_small_regions(foreground, cf.area_filtering_P)

                    if cf.task_name == 'task3':
                        foreground = foreground_improving.image_opening(foreground, cf.opening_strel,
                                                                        cf.opening_strel_size)
                        foreground = foreground_improving.image_closing(foreground, cf.closing_strel,
                                                                        cf.closing_strel_size)

                    if cf.shadow_remove:
                        shadow, highlight = foreground_improving.shadow_detection(cf, mean, image, foreground)
                        foreground = foreground - shadow - highlight

                    foreground = np.array(foreground, dtype='uint8')
                    tp_temp, fp_temp, tn_temp, fn_temp = seg_metrics.evaluate_single_image(foreground,
                                                                                           gt_img)

                    tp += tp_temp
                    fp += fp_temp
                    tn += tn_temp
                    fn += fn_temp

                pre = tp / (tp + fp) if (tp + fp) > 0 else 0.0
                rec = tp / (tp + fn) if (tp + fn) > 0 else 0.0
                f1 = 2 * pre * rec / (pre + rec + EPSILON)

                precision.append(tp / (tp + fp) if (tp + fp) > 0 else 0.0)
                recall.append(tp / (tp + fn) if (tp + fn) > 0 else 0.0)
                F1_score.append(f1)
                logger.info('[{} of {}]\talpha: {}. F1-score {} '.format(i, len(alpha_range), alpha, f1))
                i += 1

            best_f1_score = max(F1_score)
            index_alpha = F1_score.index(best_f1_score)
            best_alpha = alpha_range[index_alpha]
            logger.info('Best alpha: {:.3f}'.format(best_alpha))
            logger.info('Best F1-score: {:.3f}'.format(best_f1_score))
            visualization.plot_metrics_vs_threshold(precision, recall, F1_score, alpha_range,
                                                    cf.output_folder)

            colors = {
                'highway': 'blue',
                'fall': 'green',
                'traffic': 'orange',
            }
            color = colors.get(cf.dataset_name, 'blue')
            auc_pr = visualization.plot_precision_recall_curve(precision, recall, cf.output_folder, color=color)

            logger.info('Best alpha: {:.3f}'.format(best_alpha))
            logger.info('Best F1-score: {:.3f}'.format(best_f1_score))
            logger.info('AUC: {:.3f}'.format(auc_pr))
            if cf.save_results:
                mean = np.copy(mean_back)
                variance = np.copy(variance_back)
                logger.info('Saving results in {}'.format(cf.results_path))
                mkdirs(cf.results_path)
                for image in foreground_img_list:
                    foreground, mean, variance = background_modeling.adaptive_foreground_estimation_color(
                        image, mean, variance, best_alpha, cf.rho, cf.color_space
                    )
                    foreground = foreground_improving.hole_filling(foreground, cf.four_connectivity)

                    if cf.area_filtering:
                        # Area Filtering
                        foreground = foreground_improving.remove_small_regions(foreground, cf.area_filtering_P)

                    if cf.task_name == 'task3':
                        foreground = foreground_improving.image_opening(foreground, cf.opening_strel, cf.opening_strel_size)
                        foreground = foreground_improving.image_closing(foreground, cf.closing_strel, cf.closing_strel_size)


                    image_name = os.path.basename(image)
                    image_name = os.path.splitext(image_name)[0]
                    if cf.shadow_remove:
                        shadow, highlight = foreground_improving.shadow_detection(cf, mean, image, foreground)
                        foreground = foreground - shadow - highlight
                        shadow_comp = np.stack([foreground, shadow, highlight], axis=2)
                        cv.imwrite(os.path.join(cf.results_path, 'rgb_' + image_name + '.' + cf.result_image_type),
                                   shadow_comp * 255)
                        cv.imwrite(os.path.join(cf.results_path, 'shadow_' + image_name + '.' + cf.result_image_type),
                               foreground*255)

                    fore = np.array(foreground, dtype='uint8') * 255
                    cv.imwrite(os.path.join(cf.results_path, image_name + '.' + cf.result_image_type), fore)
Exemplo n.º 5
0
def road_statistics(cf):
    with log_context(cf.log_file):
        logger = logging.getLogger(__name__)
        logger.info(' ---> Init test: ' + cf.test_name + ' <---')

        if cf.save_results:
            logger.info('Saving results in {}'.format(cf.results_path))
            mkdirs(cf.results_path)

        image_list = get_image_list_changedetection_dataset(
            cf.dataset_path, cf.input_prefix, cf.first_image, cf.image_type,
            cf.nr_images)

        background_img_list = get_image_list_changedetection_dataset(
            cf.dataset_path, cf.input_prefix, cf.first_back, cf.image_type,
            cf.nr_back)

        visualization.visualize_lanes(cv.imread(
            background_img_list[0]), cf.lanes, (background_img_list[0].replace(
                'input', 'results').replace(cf.input_prefix, 'lane')))

        visualization.visualize_roi(
            cv.imread(background_img_list[0]), cf.roi_speed,
            (background_img_list[0].replace('input', 'results').replace(
                cf.input_prefix, 'roi')))

        mean, variance = background_modeling.multivariative_gaussian_modelling(
            background_img_list, cf.color_space)

        # Instantiate tracker for multi-object tracking
        kalman_init_params = {
            'init_estimate_error': cf.init_estimate_error,
            'motion_model_noise': cf.motion_model_noise,
            'measurement_noise': cf.measurement_noise
        }
        multi_tracker = MultiTracker(cf.cost_of_non_assignment,
                                     cf.invisible_too_long,
                                     cf.min_age_threshold, kalman_init_params)
        lanes = [Lane() for _ in range(len(cf.lanes))]

        # Tracking folder to save results
        tracking_folder = os.path.join(cf.results_path, 'tracking')
        mkdirs(tracking_folder)

        for n, image_path in tqdm(enumerate(image_list)):
            image = cv.imread(image_path)
            foreground, mean, variance = background_modeling.adaptive_foreground_estimation_color(
                image, mean, variance, cf.alpha, cf.rho, cf.color_space)

            foreground = foreground_improving.hole_filling(
                foreground, cf.four_connectivity)
            foreground = foreground_improving.remove_small_regions(
                foreground, cf.area_filtering_P)
            foreground = foreground_improving.image_opening(
                foreground, cf.opening_strel, cf.opening_strel_size)
            foreground = foreground_improving.image_closing(
                foreground, cf.closing_strel, cf.closing_strel_size)

            image_gray = skio.imread(image_path, as_grey=True)

            bboxes, centroids = detection.detectObjects(image_gray, foreground)

            # Tracking
            multi_tracker.detection_to_track_assignment(centroids)
            multi_tracker.update_assigned_tracks(bboxes, centroids)
            multi_tracker.update_unassigned_tracks()
            multi_tracker.delete_lost_tracks()
            multi_tracker.create_new_tracks(bboxes, centroids)
            multi_tracker.predict_new_locations_of_tracks()

            tracks = multi_tracker.tracks

            if n % cf.update_speed == 0:
                for lane in lanes:
                    lane.current_vehicles = 0

                for track in tracks:
                    if isinstance(cf.pixels_meter, list):
                        if track.lane != -1:
                            pix_meter = cf.pixels_meter[track.lane]
                        else:
                            pix_meter = sum(cf.pixels_meter) / len(
                                cf.pixels_meter)
                    else:
                        pix_meter = cf.pixels_meter
                    if traffic_parameters.is_inside_speed_roi(
                            track.positions[-1], cf.roi_speed):
                        # Compute speed using running average
                        try:
                            run_avg_alpha = cf.speed_estimate_running_avg
                        except AttributeError:
                            run_avg_alpha = 0.2  # Default value
                        traffic_parameters.speed(track,
                                                 pix_meter,
                                                 cf.frames_second,
                                                 dt=cf.update_speed,
                                                 alpha=run_avg_alpha)
                        track.speeds.append(track.current_speed)

                        # Detect and assign lane
                        vehicle_lane = traffic_parameters.lane_detection(
                            track.positions[-1], cf.lanes)
                        if vehicle_lane != -1 and track.lane == -1:
                            track.lane = vehicle_lane
                            lanes[vehicle_lane].total_vehicles += 1

                        # Update speeds of the lane assigned to this track
                        if track.lane != -1 and track.current_speed != 0:
                            # noinspection PyTypeChecker
                            lanes[track.lane].sum_vehicles += 1
                            # noinspection PyTypeChecker
                            lanes[track.
                                  lane].sum_velocities += track.current_speed

                for lane in lanes:
                    if lane.current_vehicles > cf.high_density:
                        lane.density = 'high'
                    else:
                        lane.density = 'low'

            if cf.save_results:
                image_name = os.path.basename(image_path)
                image_name = os.path.splitext(image_name)[0]
                save_path = os.path.join(
                    cf.results_path, image_name + '.' + cf.result_image_type)
                image = image.astype('uint8')
                image_copy = image.copy()
                visualization.display_speed_results(image, tracks,
                                                    cf.max_speed, lanes,
                                                    save_path, cf.roi_speed,
                                                    cf.margin)
                save_path = os.path.join(
                    tracking_folder,
                    image_name + '_tracking.' + cf.result_image_type)
                visualization.display_tracking_results(image_copy, tracks,
                                                       foreground, save_path)
        for n, lane in enumerate(lanes):
            average_velocity = lane.sum_velocities / lane.sum_vehicles

            if n + 1 == 1:
                logger.info(
                    '{}st lane: a total of {} vehicles have passed with an average velocity of {} km/h'
                    .format(n + 1, lane.total_vehicles, average_velocity))
            elif n + 1 == 2:
                logger.info(
                    '{}nd lane: a total of {} vehicles have passed with an average velocity of {} km/h'
                    .format(n + 1, lane.total_vehicles, average_velocity))
            elif n + 1 == 3:
                logger.info(
                    '{}rd lane: a total of {} vehicles have passed with an average velocity of {} km/h'
                    .format(n + 1, lane.total_vehicles, average_velocity))
            else:
                logger.info(
                    '{}th lane: a total of {} vehicles have passed with an average velocity of {} km/h'
                    .format(n + 1, lane.total_vehicles, average_velocity))

        logger.info(' ---> Finish test: ' + cf.test_name + ' <---')
Exemplo n.º 6
0
def background_estimation(cf):
    logger = logging.getLogger(__name__)

    # Get a list with input images filenames
    image_list = get_image_list_changedetection_dataset(
        cf.dataset_path, 'in', cf.first_image, cf.image_type, cf.nr_images)

    # Get a list with groung truth images filenames
    gt_list = get_image_list_changedetection_dataset(cf.gt_path, 'gt',
                                                     cf.first_image,
                                                     cf.gt_image_type,
                                                     cf.nr_images)
    background_img_list = image_list[:len(image_list) // 2]
    foreground_img_list = image_list[(len(image_list) // 2):]
    foreground_gt_list = gt_list[(len(image_list) // 2):]

    if cf.plot_back_model:
        output_path = os.path.join(cf.output_folder, 'gaussian_model')
        if not os.path.exists(output_path):
            os.makedirs(output_path)
        visualization.plot_back_evolution(background_img_list, cf.first_image,
                                          output_path)

    if cf.evaluate_foreground:
        logger.info('Running foreground evaluation')
        if cf.color_images:
            mean, variance = background_modeling.multivariative_gaussian_modelling(
                background_img_list, cf.color_space)
        else:
            # Model with a single Gaussian
            mean, variance = background_modeling.single_gaussian_modelling(
                background_img_list)

        alpha_range = np.linspace(cf.evaluate_alpha_range[0],
                                  cf.evaluate_alpha_range[1],
                                  num=cf.evaluate_alpha_values)
        precision, recall, f1_score, false_positive_rate = seg_metrics.evaluate_foreground_estimation(
            cf.modelling_method, foreground_img_list, foreground_gt_list, mean,
            variance, alpha_range, cf.rho, cf.color_images, cf.color_space)

        best_f1_score = max(f1_score)
        index_alpha = f1_score.index(best_f1_score)
        best_alpha = alpha_range[index_alpha]
        logger.info('Best alpha: {:.3f}'.format(best_alpha))
        logger.info('Best F1-score: {:.3f}'.format(best_f1_score))

        visualization.plot_metrics_vs_threshold(precision, recall, f1_score,
                                                alpha_range, cf.output_folder)

        colors = {
            'highway': 'blue',
            'fall': 'green',
            'traffic': 'orange',
        }
        color = colors.get(cf.dataset_name, 'blue')
        auc_pr = visualization.plot_precision_recall_curve(precision,
                                                           recall,
                                                           cf.output_folder,
                                                           color=color)

        logger.info("AUC: {}".format(auc_pr))

        for alpha_value, prec, rec, f1 in zip(alpha_range, precision, recall,
                                              f1_score):
            logger.info(
                '[alpha={:.2f}]   precision={}    recall={}    f1={}'.format(
                    alpha_value, prec, rec, f1))

    else:
        if cf.color_images:
            mean, variance = background_modeling.multivariative_gaussian_modelling(
                background_img_list, cf.color_space)
        else:
            # Model with a single Gaussian
            mean, variance = background_modeling.single_gaussian_modelling(
                background_img_list)

        if cf.modelling_method == 'non-adaptive':
            logger.info('Running single Gaussian background estimation')
            if cf.save_results:
                logger.info('Saving results in {}'.format(cf.results_path))
                mkdirs(cf.results_path)
                for image in foreground_img_list:
                    if cf.color_images:
                        foreground = background_modeling.foreground_estimation_color(
                            image, mean, variance, cf.alpha, cf.color_space)
                    else:
                        foreground = background_modeling.foreground_estimation(
                            image, mean, variance, cf.alpha)
                    image_name = os.path.basename(image)
                    image_name = os.path.splitext(image_name)[0]
                    fore = np.array(foreground, dtype='uint8') * 255
                    cv.imwrite(
                        os.path.join(cf.results_path,
                                     image_name + '.' + cf.result_image_type),
                        fore)

        elif cf.modelling_method == 'adaptive':
            logger.info(
                'Running adaptive single Gaussian background estimation')

            if cf.find_best_parameters:
                # Grid search over rho and alpha parameter space
                logger.info(
                    'Finding best alpha and rho parameters for adaptive Gaussian model.'
                )
                alpha_range = np.linspace(cf.evaluate_alpha_range[0],
                                          cf.evaluate_alpha_range[1],
                                          cf.evaluate_alpha_values)
                rho_range = np.linspace(cf.evaluate_rho_range[0],
                                        cf.evaluate_rho_range[1],
                                        cf.evaluate_rho_values)
                num_iterations = len(rho_range) * len(alpha_range)
                logger.info('Running {} iterations'.format(num_iterations))

                score_grid = np.zeros(
                    (len(alpha_range), len(rho_range)))  # score = F1-score
                precision_grid = np.zeros_like(
                    score_grid)  # for representacion purposes
                recall_grid = np.zeros_like(
                    score_grid)  # for representation purposes
                best_parameters = dict(alpha=-1, rho=-1)
                max_score = 0
                for i, (alpha, rho) in enumerate(
                        itertools.product(alpha_range, rho_range)):
                    logger.info('[{} of {}]\talpha={:.2f}\trho={:.2f}'.format(
                        i + 1, num_iterations, alpha, rho))

                    # Indices in parameter grid
                    i_idx = np.argwhere(alpha_range == alpha)
                    j_idx = np.argwhere(rho_range == rho)

                    # Compute evaluation metrics for this combination of parameters
                    _, _, _, _, precision, recall, f1_score, fpr = seg_metrics.evaluate_list_foreground_estimation(
                        cf.modelling_method, foreground_img_list,
                        foreground_gt_list, mean, variance, alpha, rho,
                        cf.color_images, cf.color_space)
                    # Store them in the array
                    score_grid[i_idx, j_idx] = f1_score
                    precision_grid[i_idx, j_idx] = precision
                    recall_grid[i_idx, j_idx] = recall

                    # Compare and select best parameters according to best score
                    if f1_score > max_score:
                        max_score = f1_score
                        best_parameters = dict(alpha=alpha, rho=rho)

                logger.info('Finished grid search')
                logger.info('Best parameters: alpha={alpha}\trho={rho}'.format(
                    **best_parameters))
                logger.info('Best F1-score: {:.3f}'.format(max_score))

                visualization.plot_adaptive_gaussian_grid_search(
                    score_grid,
                    alpha_range,
                    rho_range,
                    best_parameters,
                    best_score=max_score,
                    metric='F1-score',
                    sequence_name=cf.dataset_name)

            if cf.save_results:
                logger.info('Saving results in {}'.format(cf.results_path))
                mkdirs(cf.results_path)
                for image in foreground_img_list:
                    if cf.color_images:
                        foreground, mean, variance = background_modeling.adaptive_foreground_estimation_color(
                            image, mean, variance, cf.alpha, cf.rho,
                            cf.color_space)
                    else:
                        foreground, mean, variance = background_modeling.adaptive_foreground_estimation(
                            image, mean, variance, cf.alpha, cf.rho)
                    image_name = os.path.basename(image)
                    image_name = os.path.splitext(image_name)[0]
                    fore = np.array(foreground, dtype='uint8') * 255
                    cv.imwrite(
                        os.path.join(
                            cf.results_path, 'ADAPTIVE_' + image_name + '.' +
                            cf.result_image_type), fore)
Exemplo n.º 7
0
def main():
    log = logging.getLogger("main")
    # Get parameters from arguments
    parser = argparse.ArgumentParser(
        description='W5 - Vehicle tracker and speed estimator [Team 5]')
    parser.add_argument('-c',
                        '--config-path',
                        type=str,
                        required=True,
                        help='Configuration file path')
    parser.add_argument('-t',
                        '--test-name',
                        type=str,
                        required=True,
                        help='Name of the test')

    arguments = parser.parse_args()

    assert arguments.config_path is not None, 'Please provide a configuration' \
                                              'path using -c config/path/name' \
                                              ' in the command line'
    assert arguments.test_name is not None, 'Please provide a name for the ' \
                                            'test using -e test_name in the ' \
                                            'command line'

    # Load the configuration file
    configuration = Configuration(arguments.config_path, arguments.test_name)
    cf = configuration.load()

    log.debug("Creating background subtractor...")

    image_list = get_image_list_changedetection_dataset(
        cf.dataset_path, 'in', cf.first_image, cf.image_type, cf.nr_images)
    background_img_list = image_list[:len(image_list) // 2]
    foreground_img_list = image_list[(len(image_list) // 2):]
    log.debug("Pre-training the background subtractor...")
    mean, variance = background_modeling.multivariative_gaussian_modelling(
        background_img_list, cf.color_space)

    car_counter = None  # Will be created after first frame is captured

    frame_width = cv2.imread(background_img_list[0]).shape[1]
    frame_height = cv2.imread(background_img_list[0]).shape[0]
    log.debug("Video capture frame size=(w=%d, h=%d)", frame_width,
              frame_height)

    log.debug("Starting capture loop...")
    frame_number = -1
    for image_path in foreground_img_list:

        frame_number += 1
        log.debug("Capturing frame #%d...", frame_number)
        frame = cv2.imread(image_path)
        log.debug("Got frame #%d: shape=%s", frame_number, frame.shape)
        foreground, mean, variance = background_modeling.adaptive_foreground_estimation_color(
            image_path, mean, variance, cf.alpha, cf.rho, cf.color_space)

        foreground = foreground_improving.hole_filling(foreground,
                                                       cf.four_connectivity)
        foreground = foreground_improving.remove_small_regions(
            foreground, cf.area_filtering_P)
        foreground = foreground_improving.image_opening(
            foreground, cf.opening_strel, cf.opening_strel_size)
        foreground = foreground_improving.image_closing(
            foreground, cf.closing_strel, cf.closing_strel_size)
        foreground = foreground_improving.remove_small_regions(
            foreground, cf.area_filtering_P_post)

        if car_counter is None:
            # We do this here, so that we can initialize with actual frame size
            log.debug("Creating vehicle counter...")
            car_counter = VehicleCounter(frame.shape[:2], frame.shape[0] / 2)

        # Archive raw frames from video to disk for later inspection/testing
        if CAPTURE_FROM_VIDEO:
            save_frame(IMAGE_FILENAME_FORMAT, frame_number, frame,
                       "source frame #%d")

        log.debug("Processing frame #%d...", frame_number)
        foreground_ = np.array(foreground, dtype=np.uint8)
        processed = process_frame(frame_number, frame, foreground_,
                                  car_counter, cf)

        save_frame(cf.output_folder + "/processed_%04d.png", frame_number,
                   processed, "processed frame #%d")

        cv2.imshow('Source Image', foreground.astype('uint8') * 255)
        cv2.imshow('Processed Image', processed)

        log.debug("Frame #%d processed.", frame_number)

        c = cv2.waitKey(WAIT_TIME)
        if c == 27:
            log.debug("ESC detected, stopping...")
            break

    log.debug("Closing video capture device...")
    cv2.destroyAllWindows()
    log.debug("Done.")