How to Get the Coordinates of the Bounding Box in Yolo Object Detection

How to get the coordinates of the bounding box in YOLO object detection?

A quick solution is to modify the image.c file to print out the bounding box information:

...
if(bot > im.h-1) bot = im.h-1;

// Print bounding box values 
printf("Bounding Box: Left=%d, Top=%d, Right=%d, Bottom=%d\n", left, top, right, bot); 
draw_box_width(im, left, top, right, bot, width, red, green, blue);
...

How to get the coordinates of a bounding box in YOLO?

i had the same problem. the problem is that answer works for darknet pjreddie model. but i think you are using AlexeyAB model. if it is, you should edit image_opencv.cpp file in order to save your bounding box coordinates which is available in src folder. dont forget to re-make darknet after change.

Faster RCNN Bounding Box Coordinate

You need to apply nms and denormalize the boxes.

def apply_non_max_suppression(boxes, scores, iou_thresh=.45, top_k=200):
    """Apply non maximum suppression.
    # Arguments
        boxes: Numpy array, box coordinates of shape (num_boxes, 4)
            where each columns corresponds to x_min, y_min, x_max, y_max
        scores: Numpy array, of scores given for each box in 'boxes'
        iou_thresh : float, intersection over union threshold
            for removing boxes.
        top_k: int, number of maximum objects per class
    # Returns
        selected_indices: Numpy array, selected indices of kept boxes.
        num_selected_boxes: int, number of selected boxes.
    """

    selected_indices = np.zeros(shape=len(scores))
    if boxes is None or len(boxes) == 0:
        return selected_indices
    # x_min = boxes[:, 0]
    # y_min = boxes[:, 1]
    # x_max = boxes[:, 2]
    # y_max = boxes[:, 3]
    x_min = boxes[:, 1]
    y_min = boxes[:, 0]
    x_max = boxes[:, 3]
    y_max = boxes[:, 2]

    areas = (x_max - x_min) * (y_max - y_min)
    remaining_sorted_box_indices = np.argsort(scores)
    remaining_sorted_box_indices = remaining_sorted_box_indices[-top_k:]

    num_selected_boxes = 0
    while len(remaining_sorted_box_indices) > 0:
        best_score_args = remaining_sorted_box_indices[-1]
        selected_indices[num_selected_boxes] = best_score_args
        num_selected_boxes = num_selected_boxes + 1
        if len(remaining_sorted_box_indices) == 1:
            break

        remaining_sorted_box_indices = remaining_sorted_box_indices[:-1]

        best_x_min = x_min[best_score_args]
        best_y_min = y_min[best_score_args]
        best_x_max = x_max[best_score_args]
        best_y_max = y_max[best_score_args]

        remaining_x_min = x_min[remaining_sorted_box_indices]
        remaining_y_min = y_min[remaining_sorted_box_indices]
        remaining_x_max = x_max[remaining_sorted_box_indices]
        remaining_y_max = y_max[remaining_sorted_box_indices]

        inner_x_min = np.maximum(remaining_x_min, best_x_min)
        inner_y_min = np.maximum(remaining_y_min, best_y_min)
        inner_x_max = np.minimum(remaining_x_max, best_x_max)
        inner_y_max = np.minimum(remaining_y_max, best_y_max)

        inner_box_widths = inner_x_max - inner_x_min
        inner_box_heights = inner_y_max - inner_y_min

        inner_box_widths = np.maximum(inner_box_widths, 0.0)
        inner_box_heights = np.maximum(inner_box_heights, 0.0)

        intersections = inner_box_widths * inner_box_heights
        remaining_box_areas = areas[remaining_sorted_box_indices]
        best_area = areas[best_score_args]
        unions = remaining_box_areas + best_area - intersections
        intersec_over_union = intersections / unions
        intersec_over_union_mask = intersec_over_union <= iou_thresh
        remaining_sorted_box_indices = remaining_sorted_box_indices[
            intersec_over_union_mask]

    return selected_indices.astype(int), num_selected_boxes

def denormalize_box(box, image_shape):
    """Scales corner box coordinates from normalized values to image dimensions.
    # Arguments
        box: Numpy array containing corner box coordinates.
        image_shape: List of integers with (height, width).
    # Returns
        returns: box corner coordinates in image dimensions
    """
    # x_min, y_min, x_max, y_max = box[:4]
    y_min, x_min, y_max, x_max = box[:4]

    height, width = image_shape
    x_min = int(x_min * width)
    y_min = int(y_min * height)
    x_max = int(x_max * width)
    y_max = int(y_max * height)

    # return [x_min, y_min, x_max, y_max]
    return [y_min, x_min, y_max, x_max]

(boxes, scores, classes, num) = sess.run(
    [detection_boxes, detection_scores, detection_classes, num_detections],
    feed_dict={image_tensor: image_expanded})

conf_threshold = 0.5
nms_threshold = 0.45
image_shape = image.shape[:2]

# Filtering the boxes based on conf_threshold
filtered_scores = [scores[0][i] for i in np.where(scores[0] > conf_threshold)]
filtered_boxes = [boxes[0][i] for i in np.where(scores[0] > conf_threshold)]
filtered_classes = [classes[0][i] for i in np.where(scores[0] > conf_threshold)]

if len(filtered_scores[0]) != 0:
            # NMS thresholding
    indices, count = apply_non_max_suppression(filtered_boxes[0], filtered_scores[0], nms_threshold, 200)
    selected_indices = indices[:count]

    ## Getting the final boxes
    final_boxes = filtered_boxes[0][selected_indices]
    final_scores = filtered_scores[0][selected_indices]
    final_classes = filtered_classes[0][selected_indices]


    final_boxes = [denormalize_box(box, image_shape) for box in final_boxes]

How do I get z-axis coordinate from ply file for a given point ( x, y ) in python?

Finally figured out what i was doing wrong.
This is the correct working code. Cheers!

#Enter your x & y coors to get corresponding z-axis value

x =  2300          
y =  1822     

xy = np.array([x, y])
z = coors[np.all(np.isclose(coors[:, :2], xy), axis=1), 2][0]
print("x= {}  y= {}  z= {}".format(x, y, z))

---

Related Topics