def run_edge_boxes(image_file, num_proposals, draw_only_positives): img = cv2.imread('./JPEGImages/' + image_file + '.jpg') parameters_combinations = [(0.25, 0.85), (0.45, 0.45), (0.65, 0.75), (0.85, 0.35), (0.85, 0.85)] recall_list = [] for parameter_tuple in parameters_combinations: edge_detection = cv2.ximgproc.createStructuredEdgeDetection( 'model.yml.gz') rgb_im = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) edges = edge_detection.detectEdges(np.float32(rgb_im / 255.0)) orientation = edge_detection.computeOrientation(edges) edges = edge_detection.edgesNms(edges, orientation) edge_boxes = cv2.ximgproc.createEdgeBoxes(alpha=parameter_tuple[0], beta=parameter_tuple[1]) proposal_boxes, scores = edge_boxes.getBoundingBoxes( edges, orientation) image_output = img.copy() if len(proposal_boxes) > 0: boxes_scores = zip(proposal_boxes, scores) for i, b_s in enumerate(boxes_scores): if (i < num_proposals): box = b_s[0] x, y, w, h = box if draw_only_positives and not utils.compare_gt( (x, y, x + w, y + h)): continue cv2.rectangle(image_output, (x, y), (x + w, y + h), (0, 255, 0), 1, cv2.LINE_AA) score = b_s[1][0] cv2.putText(image_output, "{:.2f}".format(score), (x, y), cv2.FONT_HERSHEY_PLAIN, 0.8, (255, 255, 255), 1, cv2.LINE_AA) # print("score={:f}".format(score)) else: break if draw_only_positives: utils.draw_groundtruth(image_output) recall_list.append(utils.compute_recall(proposal_boxes)) # cv2.imshow("Edgeboxes output " + str(parameter_tuple), image_output) cv2.imwrite( "./eb_output_" + image_file + "_" + str(parameter_tuple) + ".jpg", image_output) # cv2.waitKey(0) # cv2.destroyAllWindows() return recall_list
def generate_results(gt, pred): cm = confusion_matrix(gt, pred, labels=[0, 1]) my_f1 = compute_f1(cm) my_precision = compute_precision(cm) my_recall = compute_recall(cm) prec, rec, f1, _ = precision_recall_fscore_support(gt, pred, labels=[0, 1], average=None) assert ((my_precision - prec) < 1e-3).all() assert ((my_recall - rec) < 1e-3).all() assert ((my_f1 - f1) < 1e-3).all() return cm, prec, rec, f1
def run_selective_search(image_file, num_proposals, draw_only_positives): img = cv2.imread('./JPEGImages/' + image_file + '.jpg') # create Selective Search Segmentation Object using default parameters ss = cv2.ximgproc.segmentation.createSelectiveSearchSegmentation() ss.setBaseImage(img) strategy_color = cv2.ximgproc.segmentation.createSelectiveSearchSegmentationStrategyColor( ) strategy_texture = cv2.ximgproc.segmentation.createSelectiveSearchSegmentationStrategyTexture( ) strategy_size = cv2.ximgproc.segmentation.createSelectiveSearchSegmentationStrategySize( ) strategy_fill = cv2.ximgproc.segmentation.createSelectiveSearchSegmentationStrategyFill( ) strategy_combined = cv2.ximgproc.segmentation.createSelectiveSearchSegmentationStrategyMultiple( strategy_color, strategy_texture, strategy_size, strategy_fill) strategies = [ strategy_texture, strategy_color, strategy_size, strategy_fill, strategy_combined ] recall_list = [] for strategy in strategies: ss.addStrategy(strategy) ss.switchToSelectiveSearchFast() # ss.switchToSelectiveSearchQuality() prososal_boxes = ss.process() image_output = img.copy() # iterate over all the region proposals for i, rect in enumerate(prososal_boxes): # draw rectangle for region proposal till numShowRects if (i < num_proposals): x, y, w, h = rect if draw_only_positives and not utils.compare_gt( (x, y, x + w, y + h)): continue cv2.rectangle(image_output, (x, y), (x + w, y + h), (0, 255, 0), 1, cv2.LINE_AA) else: break if draw_only_positives: utils.draw_groundtruth(image_output) recall_list.append(utils.compute_recall(prososal_boxes)) # cv2.imshow("Selective search output " + str(strategy), image_output) cv2.imwrite( "./ss_output_" + "_" + image_file + "_" + str(strategy) + ".jpg", image_output) # cv2.waitKey(0) ss.clearStrategies() # cv2.destroyAllWindows() return recall_list
image_to_gt = utils.load_evaluation_set(hp, files['iota10k'], files['gt_fn'], args.min_rater_count) # Arrange metrics for the gt labels in df. image_metrics = utils.compute_image_metrics(image_to_gt, label_metrics, files, method=hp['eval_method'], do_verify=hp['do_verify'], gt_in_voc=hp['gt_vocab'], y_force=hp['y_force']) images = list(set(image_metrics.ImageID.values.tolist())) raters_ub = utils.raters_performance(images, files['gt_fn']) print('Raters agreement: %s' % raters_ub) # Compute precision & recall over all metrics. precision, sem_p, precision_mat = utils.compute_precision( image_metrics, hp['k']) recall, sem_r, recall_mat = utils.compute_recall(image_metrics, hp['k']) vis.print_top_pr(precision, recall) utils.save_results(hp, files['results_dir'], precision, sem_p, recall, sem_r) # Plot precision, recall and correlation. Save specific examples to HTML. if args.plot_figures: vis.plot_precision(hp, files, precision, sem_p, raters_ub) vis.plot_recall(hp, files, recall, sem_r) vis.plot_precision_vs_recall(hp, files, precision, recall, raters_ub) # vis.plot_correlation(hp, files, image_metrics) vis.write_models_to_html(image_metrics, hp, files)
# These are the same as the previous step (refined anchors # after NMS) but with coordinates normalized to [0, 1] range. limit = 50 # Convert back to image coordinates for display h, w = config.IMAGE_SHAPE[:2] proposals = rpn['proposals'][0, :limit] * np.array([h, w, h, w]) visualize.draw_boxes(image, refined_boxes=proposals, ax=get_ax()) # Measure the RPN recall (percent of objects covered by anchors) # Here we measure recall for 3 different methods: # - All anchors # - All refined anchors # - Refined anchors after NMS iou_threshold = 0.7 recall, positive_anchor_ids = utils.compute_recall(model.anchors, gt_bbox, iou_threshold) print("All Anchors ({:5}) Recall: {:.3f} Positive anchors: {}".format( model.anchors.shape[0], recall, len(positive_anchor_ids))) recall, positive_anchor_ids = utils.compute_recall(rpn['refined_anchors'][0], gt_bbox, iou_threshold) print("Refined Anchors ({:5}) Recall: {:.3f} Positive anchors: {}".format( rpn['refined_anchors'].shape[1], recall, len(positive_anchor_ids))) recall, positive_anchor_ids = utils.compute_recall(proposals, gt_bbox, iou_threshold) print("Post NMS Anchors ({:5}) Recall: {:.3f} Positive anchors: {}".format( proposals.shape[0], recall, len(positive_anchor_ids))) # Get input and output to classifier and mask heads. mrcnn = model.run_graph([image], [
# image_ids = np.random.choice(dataset_val.image_ids, 10) APs = [] recalls_list = [] precisions_list = [] for image_id in range(80): # Load image and ground truth data image, image_meta, gt_class_id, gt_bbox, gt_mask = \ modellib.load_image_gt(dataset_val, inference_config, image_id, use_mini_mask=False) molded_images = np.expand_dims(modellib.mold_image(image, inference_config), 0) # Run object detection results = model.detect([image], verbose=0) r = results[0] # Compute AP AP, precisions, recalls, overlaps = \ utils.compute_ap(gt_bbox, gt_class_id, r["rois"], r["class_ids"], r["scores"]) APs.append(AP) recall, precision = utils.compute_recall(r['rois'], gt_bbox, iou=0.5) recalls_list.append(recall) precisions_list.append(precision) print("mAP: ", np.mean(APs)) print("recalls_list: ", np.mean(recalls)) print("precisions_list: ", np.mean(precisions))