Spaces:
Paused
Paused
import cv2 | |
import numpy as np | |
def class_Order(boxes, categories): | |
Z = [] | |
# Z = [x for _,x in sorted(zip(categories, boxes))] | |
cate = np.argsort(categories) | |
for index in cate: | |
Z.append(boxes[index]) | |
return Z | |
def non_max_suppression_fast(boxes, labels, overlapThresh): | |
# if there are no boxes, return an empty list | |
if len(boxes) == 0: | |
return [] | |
# if the bounding boxes integers, convert them to floats -- | |
# this is important since we'll be doing a bunch of divisions | |
if boxes.dtype.kind == "i": | |
boxes = boxes.astype("float") | |
# initialize the list of picked indexes | |
pick = [] | |
# grab the coordinates of the bounding boxes | |
x1 = boxes[:, 1] | |
y1 = boxes[:, 0] | |
x2 = boxes[:, 3] | |
y2 = boxes[:, 2] | |
# compute the area of the bounding boxes and sort the bounding | |
# boxes by the bottom-right y-coordinate of the bounding box | |
area = (x2 - x1 + 1) * (y2 - y1 + 1) | |
idxs = np.argsort(y2) | |
# keep looping while some indexes still remain in the indexes | |
# list | |
while len(idxs) > 0: | |
# grab the last index in the indexes list and add the | |
# index value to the list of picked indexes | |
last = len(idxs) - 1 | |
i = idxs[last] | |
pick.append(i) | |
# find the largest (x, y) coordinates for the start of | |
# the bounding box and the smallest (x, y) coordinates | |
# for the end of the bounding box | |
xx1 = np.maximum(x1[i], x1[idxs[:last]]) | |
yy1 = np.maximum(y1[i], y1[idxs[:last]]) | |
xx2 = np.minimum(x2[i], x2[idxs[:last]]) | |
yy2 = np.minimum(y2[i], y2[idxs[:last]]) | |
# compute the width and height of the bounding box | |
w = np.maximum(0, xx2 - xx1 + 1) | |
h = np.maximum(0, yy2 - yy1 + 1) | |
# compute the ratio of overlap | |
overlap = (w * h) / area[idxs[:last]] | |
# delete all indexes from the index list that have | |
idxs = np.delete( | |
idxs, np.concatenate(([last], np.where(overlap > overlapThresh)[0])) | |
) | |
# return only the bounding boxes that were picked using the | |
# integer data type | |
final_labels = [labels[idx] for idx in pick] | |
final_boxes = boxes[pick].astype("int") | |
return final_boxes, final_labels | |
def get_center_point(box): | |
left, top, right, bottom = box | |
return left + ((right - left) // 2), top + ( | |
(bottom - top) // 2 | |
) # (x_c, y_c) # Need to fix bottom_left and bottom_right | |
def order_points(pts): | |
rect = np.zeros((4, 2), dtype="float32") | |
s = pts.sum(axis=1) | |
rect[0] = pts[np.argmin(s)] | |
rect[2] = pts[np.argmax(s)] | |
diff = np.diff(pts, axis=1) | |
rect[1] = pts[np.argmin(diff)] | |
rect[3] = pts[np.argmax(diff)] | |
return rect | |
def four_point_transform(image, pts): | |
image = np.asarray(image) | |
rect = order_points(pts) | |
(tl, tr, br, bl) = rect | |
widthA = np.sqrt(((br[0] - bl[0]) ** 2) + ((br[1] - bl[1]) ** 2)) | |
widthB = np.sqrt(((tr[0] - tl[0]) ** 2) + ((tr[1] - tl[1]) ** 2)) | |
maxWidth = max(int(widthA), int(widthB)) | |
heightA = np.sqrt(((tr[0] - br[0]) ** 2) + ((tr[1] - br[1]) ** 2)) | |
heightB = np.sqrt(((tl[0] - bl[0]) ** 2) + ((tl[1] - bl[1]) ** 2)) | |
maxHeight = max(int(heightA), int(heightB)) | |
dst = np.array( | |
[[0, 0], [maxWidth - 1, 0], [maxWidth - 1, maxHeight - 1], [0, maxHeight - 1]], | |
dtype="float32", | |
) | |
M = cv2.getPerspectiveTransform(rect, dst) | |
warped = cv2.warpPerspective(image, M, (maxWidth, maxHeight)) | |
return warped | |
# def getMissingCorner(categories, boxes): # boxes: top_left, top_right, bottom_left, bottom_right | |
# if 0 not in categories: # Missing top_left | |
# delta_vertical = boxes[3][2] - boxes[1][2] | |
# delta_horizon = boxes[3][3] - boxes[2][3] | |
# x_miss = | |