Spaces:
Running
Running
| from modules.utils import class_dict, resize_boxes, resize_keypoints, find_other_keypoint | |
| import cv2 | |
| import numpy as np | |
| import torch | |
| import matplotlib.pyplot as plt | |
| from modules.OCR import group_texts | |
| def draw_stream(image, | |
| prediction=None, | |
| text_predictions=None, | |
| class_dict=class_dict, | |
| draw_keypoints=False, | |
| draw_boxes=False, | |
| draw_text=False, | |
| draw_links=False, | |
| draw_twins=False, | |
| draw_grouped_text=False, | |
| write_class=False, | |
| write_score=False, | |
| write_text=False, | |
| score_threshold=0.4, | |
| write_idx=False, | |
| keypoints_correction=False, | |
| new_size=(1333, 1333), | |
| only_show=None, | |
| axis=False, | |
| return_image=False, | |
| resize=False): | |
| """ | |
| Draws annotations on images including bounding boxes, keypoints, links, and text. | |
| Parameters: | |
| - image (np.array): The image on which annotations will be drawn. | |
| - target (dict): Ground truth data containing boxes, labels, etc. | |
| - prediction (dict): Prediction data from a model. | |
| - full_prediction (dict): Additional detailed prediction data, potentially including relationships. | |
| - text_predictions (tuple): OCR text predictions containing bounding boxes and texts. | |
| - class_dict (dict): Mapping from class IDs to class names. | |
| - draw_keypoints (bool): Flag to draw keypoints. | |
| - draw_boxes (bool): Flag to draw bounding boxes. | |
| - draw_text (bool): Flag to draw text annotations. | |
| - draw_links (bool): Flag to draw links between annotations. | |
| - draw_twins (bool): Flag to draw twins keypoints. | |
| - write_class (bool): Flag to write class names near the annotations. | |
| - write_score (bool): Flag to write scores near the annotations. | |
| - write_text (bool): Flag to write OCR recognized text. | |
| - score_threshold (float): Threshold for scores above which annotations will be drawn. | |
| - only_show (str): Specific class name to filter annotations by. | |
| - resize (bool): Whether to resize annotations to fit the image size. | |
| """ | |
| #delete the global pool if it is the only one to show | |
| """if len(prediction['pool_dict'])==1 and prediction['labels'][-1]==6: | |
| pool_index = list(prediction['pool_dict'])[0] | |
| if len(prediction['pool_dict'][pool_index])==(len(prediction['boxes'])-1): | |
| prediction['boxes'] = prediction['boxes'][:-1] | |
| prediction['labels'] = prediction['labels'][:-1] | |
| prediction['scores'] = prediction['scores'][:-1] | |
| prediction['keypoints'] = prediction['keypoints'][:-1] | |
| prediction['links'] = prediction['links'][:-1]""" | |
| # Convert image to RGB (if not already in that format) | |
| if prediction is None: | |
| image = image.squeeze(0).permute(1, 2, 0).cpu().numpy() | |
| image_copy = image.copy() | |
| scale = max(image.shape[0], image.shape[1]) / 1000 | |
| original_size = (image.shape[0], image.shape[1]) | |
| # Calculate scale to fit the new size while maintaining aspect ratio | |
| scale_ = min(new_size[0] / original_size[0], new_size[1] / original_size[1]) | |
| new_scaled_size = (int(original_size[0] * scale_), int(original_size[1] * scale_)) | |
| for i in range(len(prediction['boxes'])): | |
| if only_show is not None and only_show != 'all': | |
| if prediction['labels'][i] != list(class_dict.values()).index(only_show): | |
| continue | |
| box = prediction['boxes'][i] | |
| x1, y1, x2, y2 = box | |
| if resize: | |
| x1, y1, x2, y2 = resize_boxes(np.array([box]), (new_scaled_size[1], new_scaled_size[0]), (image_copy.shape[1],image_copy.shape[0]))[0] | |
| score = prediction['scores'][i] | |
| if score < score_threshold: | |
| continue | |
| if draw_boxes: | |
| #dont show the lanes | |
| if prediction['labels'][i] == list(class_dict.values()).index('lane'): | |
| continue | |
| cv2.rectangle(image_copy, (int(x1), int(y1)), (int(x2), int(y2)), (0, 0, 0), int(2*scale)) | |
| if write_score: | |
| cv2.putText(image_copy, str(round(score, 2)), (int(x1), int(y1) + int(15*scale)), cv2.FONT_HERSHEY_SIMPLEX, scale/2, (100,100, 255), 2) | |
| if write_idx: | |
| cv2.putText(image_copy, str(i), (int(x1) + int(15*scale), int(y1) + int(15*scale)), cv2.FONT_HERSHEY_SIMPLEX, 2*scale, (0,0, 0), 2) | |
| if write_class and 'labels' in prediction: | |
| class_id = prediction['labels'][i] | |
| cv2.putText(image_copy, class_dict[class_id], (int(x1), int(y1) - int(2*scale)), cv2.FONT_HERSHEY_SIMPLEX, scale/2, (255, 100, 100), 2) | |
| # Draw keypoints if available | |
| if draw_keypoints and 'keypoints' in prediction: | |
| for i in range(len(prediction['keypoints'])): | |
| if i >= len(prediction['keypoints']): | |
| continue | |
| kp = prediction['keypoints'][i] | |
| for j in range(kp.shape[0]): | |
| if prediction['labels'][i] != list(class_dict.values()).index('sequenceFlow') and prediction['labels'][i] != list(class_dict.values()).index('messageFlow') and prediction['labels'][i] != list(class_dict.values()).index('dataAssociation'): | |
| continue | |
| score = prediction['scores'][i] | |
| if score < score_threshold: | |
| continue | |
| x,y, v = np.array(kp[j]) | |
| x, y, v = resize_keypoints(np.array([kp[j]]), (new_scaled_size[1],new_scaled_size[0]), (image_copy.shape[1],image_copy.shape[0]))[0] | |
| if j == 0: | |
| cv2.circle(image_copy, (int(x), int(y)), int(5*scale), (0, 0, 255), -1) | |
| else: | |
| cv2.circle(image_copy, (int(x), int(y)), int(5*scale), (255, 0, 0), -1) | |
| # Draw text predictions if available | |
| if (draw_text or write_text) and text_predictions is not None: | |
| for i in range(len(text_predictions[0])): | |
| x1, y1, x2, y2 = text_predictions[0][i] | |
| text = text_predictions[1][i] | |
| if resize: | |
| x1, y1, x2, y2 = resize_boxes(np.array([[float(x1), float(y1), float(x2), float(y2)]]), (new_scaled_size[1], new_scaled_size[0]), (image_copy.shape[1],image_copy.shape[0]))[0] | |
| if draw_text: | |
| cv2.rectangle(image_copy, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), int(2*scale)) | |
| if write_text: | |
| cv2.putText(image_copy, text, (int(x1 + int(2*scale)), int((y1+y2)/2) ), cv2.FONT_HERSHEY_SIMPLEX, scale/2, (0,0, 0), 2) | |
| '''Draws links between objects based on the full prediction data.''' | |
| #check if keypoints detected are the same | |
| if draw_twins and prediction is not None: | |
| # Pre-calculate indices for performance | |
| circle_color = (0, 255, 0) # Green color for the circle | |
| circle_radius = int(10 * scale) # Circle radius scaled by image scale | |
| for idx, (key1, key2) in enumerate(prediction['keypoints']): | |
| if prediction['labels'][idx] not in [list(class_dict.values()).index('sequenceFlow'), | |
| list(class_dict.values()).index('messageFlow'), | |
| list(class_dict.values()).index('dataAssociation')]: | |
| continue | |
| # Calculate the Euclidean distance between the two keypoints | |
| distance = np.linalg.norm(key1[:2] - key2[:2]) | |
| if distance < 10: | |
| x_new,y_new, x,y = find_other_keypoint(idx,prediction) | |
| cv2.circle(image_copy, (int(x), int(y)), circle_radius, circle_color, -1) | |
| cv2.circle(image_copy, (int(x_new), int(y_new)), circle_radius, (0,0,0), -1) | |
| # Draw links between objects | |
| if draw_links==True and prediction is not None: | |
| for i, (start_idx, end_idx) in enumerate(prediction['links']): | |
| if start_idx is None or end_idx is None: | |
| continue | |
| start_box = prediction['boxes'][start_idx] | |
| start_box = resize_boxes(np.array([start_box]), (new_scaled_size[1], new_scaled_size[0]), (image_copy.shape[1],image_copy.shape[0]))[0] | |
| end_box = prediction['boxes'][end_idx] | |
| end_box = resize_boxes(np.array([end_box]), (new_scaled_size[1], new_scaled_size[0]), (image_copy.shape[1],image_copy.shape[0]))[0] | |
| current_box = prediction['boxes'][i] | |
| current_box = resize_boxes(np.array([current_box]), (new_scaled_size[1], new_scaled_size[0]), (image_copy.shape[1],image_copy.shape[0]))[0] | |
| # Calculate the center of each bounding box | |
| start_center = ((start_box[0] + start_box[2]) // 2, (start_box[1] + start_box[3]) // 2) | |
| end_center = ((end_box[0] + end_box[2]) // 2, (end_box[1] + end_box[3]) // 2) | |
| current_center = ((current_box[0] + current_box[2]) // 2, (current_box[1] + current_box[3]) // 2) | |
| # Draw a line between the centers of the connected objects | |
| cv2.line(image_copy, (int(start_center[0]), int(start_center[1])), (int(current_center[0]), int(current_center[1])), (0, 0, 255), int(2*scale)) | |
| cv2.line(image_copy, (int(current_center[0]), int(current_center[1])), (int(end_center[0]), int(end_center[1])), (255, 0, 0), int(2*scale)) | |
| if draw_grouped_text and prediction is not None: | |
| task_boxes = task_boxes = [box for i, box in enumerate(prediction['boxes']) if prediction['labels'][i] == list(class_dict.values()).index('task')] | |
| grouped_sentences, sentence_bounding_boxes, info_texts, info_boxes = group_texts(task_boxes, text_predictions[0], text_predictions[1], percentage_thresh=1) | |
| for i in range(len(info_boxes)): | |
| x1, y1, x2, y2 = info_boxes[i] | |
| x1, y1, x2, y2 = resize_boxes(np.array([[float(x1), float(y1), float(x2), float(y2)]]), (new_scaled_size[1], new_scaled_size[0]), (image_copy.shape[1],image_copy.shape[0]))[0] | |
| cv2.rectangle(image_copy, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), int(2*scale)) | |
| for i in range(len(sentence_bounding_boxes)): | |
| x1,y1,x2,y2 = sentence_bounding_boxes[i] | |
| x1, y1, x2, y2 = resize_boxes(np.array([[float(x1), float(y1), float(x2), float(y2)]]), (new_scaled_size[1], new_scaled_size[0]), (image_copy.shape[1],image_copy.shape[0]))[0] | |
| cv2.rectangle(image_copy, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), int(2*scale)) | |
| if return_image: | |
| return image_copy | |
| else: | |
| # Display the image | |
| plt.figure(figsize=(12, 12)) | |
| plt.imshow(image_copy) | |
| if axis==False: | |
| plt.axis('off') | |
| plt.show() |