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 = | |