| #!usr/bin/python3 | |
| import rclpy | |
| from rclpy.node import Node | |
| from rclpy.qos import QoSProfile, QoSReliabilityPolicy, QoSHistoryPolicy | |
| # from realsense2_camera_msgs.msg import RGBD | |
| from sensor_msgs.msg import Image | |
| from std_msgs.msg import Float32 | |
| from std_msgs.msg import Int32 | |
| from autoboat_msgs.msg import ObjectDetectionResultsList | |
| from cv_bridge import CvBridge | |
| from ultralytics import YOLO | |
| import cv2 | |
| import numpy as np | |
| from math import sqrt | |
| import os | |
| current_directory_path = os.path.dirname(os.path.realpath(__file__)) | |
| TRAINED_IMAGE_SIZE = (640, 640) # pixel width and height of the images that the model was trained on | |
| IMAGE_CONFIDENCE = 0.3 | |
| SHOULD_SAVE_IMAGES = False | |
| class BuoyDetectionNode(Node): | |
| def __init__(self): | |
| super().__init__("buoy_detection") | |
| self.model = YOLO(f"{current_directory_path}/weights/pretty_good_11l_train32.pt") | |
| self.cv_bridge = CvBridge() | |
| self.current_image_rgb = None | |
| self.depth_image = None | |
| self.image_to_save_index = 0 # images are saved in the format name[index].jpg so this just keeps track of the current index of the image so that we don't overwrite other images | |
| sensor_qos_profile = QoSProfile(reliability=QoSReliabilityPolicy.BEST_EFFORT, history=QoSHistoryPolicy.KEEP_LAST, depth=1) | |
| self.buoy_angle_pub = self.create_publisher(Float32, "/buoy_angle", 10) | |
| self.buoy_depth_pixel_pub = self.create_publisher(Float32, "/buoy_depth_pixel", 10) | |
| # self.depth_image_listener = self.create_subscription( | |
| # msg_type=Image, | |
| # topic="/camera/camera/aligned_depth_to_color/image_raw", | |
| # callback=self.depth_image_callback, | |
| # qos_profile=sensor_qos_profile, | |
| # ) | |
| # self.depth_image_listener = self.create_subscription(msg_type=Image, topic="/camera/depth/image_rect_raw", callback=self.depth_image_callback, qos_profile=sensor_qos_profile) | |
| self.rgb_image_listener = self.create_subscription( | |
| msg_type=Image, topic="/camera/camera/color/image_raw", callback=self.rgb_image_callback, qos_profile=sensor_qos_profile | |
| ) | |
| # self.object_detection_results_publisher = self.create_publisher(msg_type=ObjectDetectionResults, topic="/object_detection_results", qos_profile=sensor_qos_profile) | |
| self.create_timer(timer_period_sec=0.001, callback=self.perform_inference) | |
| def depth_image_callback(self, depth_image: Image): | |
| self.get_logger().info("got here depth") # print(f"hihihihi") | |
| # top = 0 | |
| # bottom = smaller_size | |
| # TODO downscale the image so that the smallest dimension is 640p | |
| # TODO: crop the image properly | |
| # cropped_depth_image_cv = depth_image_cv[left:right, top:bottom] | |
| # cropped_rgb_image_cv = rgb_image_cv | |
| # depth_image_cv.resize(TRAINED_IMAGE_SIZE)f"The type of the cv image is | |
| # rgb_image_cv.resize(TRAINED_IMAGE_SIZE) | |
| depth_image_cv = self.cv_bridge.imgmsg_to_cv2(depth_image, desired_encoding=depth_image.encoding) | |
| print(f"cropped image shape: {depth_image_cv.shape}") | |
| # cv2.imwrite('depth_image.jpg', depth_image_cv) | |
| print(f"The type of the cv image is {type(depth_image_cv)}") | |
| self.depth_image = depth_image_cv | |
| # np.where(depth_image_cv > 0) | |
| # print(depth_image_cv) | |
| def rgb_image_callback(self, rgb_image: Image): | |
| self.get_logger().info("got here rgb") | |
| self.current_image_rgb = self.cv_bridge.imgmsg_to_cv2(rgb_image, "bgr8") | |
| self.current_image_rgb = self.current_image_rgb[80:1200, 40:680] # crop the image to 640,640 | |
| def perform_inference(self): | |
| # https://docs.ultralytics.com/modes/predict/#inference-sources | |
| if self.current_image_rgb is None: | |
| return | |
| results = self.model.predict( | |
| [ | |
| self.current_image_rgb, | |
| ], | |
| conf=IMAGE_CONFIDENCE, | |
| ) # return a list of Results objects | |
| # Added variable for real-time inference | |
| DIAGONAL_FIELD_OF_VIEW = 89 | |
| # Process results list | |
| print(f"The length of the results object is {len(results)}") | |
| result = results[0] | |
| boxes = result.boxes # Boxes object for bounding box outputs | |
| # print(f"boxes: {boxes}") | |
| # masks = result.masks # Masks object for segmentation masks outputs | |
| # keypoints = result.keypoints # Keypoints object for pose outputs | |
| # probs = result.probs # Probs object for classification outputs | |
| # obb = result.obb # Oriented boxes object for OBB outputs | |
| height = result.orig_shape[0] | |
| width = result.orig_shape[1] | |
| diagonal = sqrt(height**2 + width**2) | |
| deg_per_pixel = DIAGONAL_FIELD_OF_VIEW / diagonal | |
| boxes = result.boxes | |
| # conf_angle = {} | |
| angle_list = [] | |
| conf_list = [] | |
| x_list = [] | |
| y_list = [] | |
| box_y_center = 0 | |
| box_x_center = 0 | |
| if boxes.shape[0] == 0: | |
| return | |
| self.get_logger().info("We are finally getting something") | |
| for box in boxes: | |
| print(box.conf.item()) | |
| box_location = box.xywh | |
| # The Y stuff is only for trying to get depth image values | |
| # box_centerx_location = box_location[0][0].item() + box_location[0][2].item()/2 | |
| # box_centery_location = box_location[0][1].item() + box_location[0][3].item()/2 | |
| box_centerx_location = box_location[0][0].item() | |
| box_centery_location = box_location[0][1].item() | |
| print(f"X-coordinate: {box_centerx_location}") | |
| print(f"Y-coordinate: {box_centery_location}") | |
| # print(f"non-absolute-value-x-location: {(width/2)-box_centerx_location}") | |
| # print(f"non-absolute-value-y-location: {(height/2)-box_centery_location}") | |
| x_distance_from_center = box_centerx_location - (width / 2) | |
| img_angle_from_center = x_distance_from_center * deg_per_pixel | |
| # conf_angle[box.conf.item()]=img_angle_from_center | |
| angle_list.append(img_angle_from_center) | |
| conf_list.append(box.conf.item()) | |
| x_list.append(box_centerx_location) | |
| y_list.append(box_centery_location) | |
| # Trying to get the maximum confidence keys for the x and y locations for the conf box dictionaries -- FAILED, kept just in case | |
| # Skip to after the returning of the angle to see this used | |
| # max_conf_x_key = min(conf_x_box, key=conf_x_box.get) | |
| # max_conf_y_key = min(conf_y_box, key=conf_y_box.get) | |
| # print(f"The keys of the x dictionary are {conf_x_box.keys()}") | |
| # print(f"The keys of the y dictionary are {conf_y_box.keys()}") | |
| # print(f"max_conf_x_key: {max_conf_x_key}") | |
| # print(f"max_conf_y_key: {max_conf_y_key}") | |
| max_conf_index = np.argmax(conf_list) | |
| # y_avg_distance_from_center = sum_y/count | |
| # print(f"The confidence angle pairs sorted are {dict(sorted(conf_angle.items(), reverse=True))}") | |
| # max_angle_key = max(conf_angle, key=conf_angle.get) | |
| # print(f"The angle of the maximum confidence box is {conf_angle[max_angle_key]}") | |
| max_conf_angle = angle_list[max_conf_index] | |
| print(f"The most confident buoy angle is: {max_conf_angle}") | |
| msg = Float32() | |
| msg.data = max_conf_angle | |
| self.buoy_angle_pub.publish(msg) | |
| # Need to get the x,y location of the buoy/center of the bounding box | |
| box_x_center = x_list[max_conf_index] | |
| box_y_center = y_list[max_conf_index] | |
| print(f"The type of the current image is {type(self.current_image_rgb)}") | |
| print(f"The value at the index is {self.current_image_rgb[int(box_y_center), int(box_x_center)]}") | |
| # self.current_image_rgb[int(box_x_center), int(box_y_center)]= (160, 32, 240) | |
| # self.current_image_rgb[int(box_x_center+1), int(box_y_center)]= (160, 32, 240) | |
| # self.current_image_rgb[int(box_x_center+2), int(box_y_center)]= (160, 32, 240) | |
| # self.current_image_rgb[int(box_x_center-1), int(box_y_center)]= (160, 32, 240) | |
| # self.current_image_rgb[int(box_x_center-2), int(box_y_center)]= (160, 32, 240) | |
| # self.current_image_rgb[int(box_x_center), int(box_y_center-1)]= (160, 32, 240) | |
| # self.current_image_rgb[int(box_x_center), int(box_y_center-2)]= (160, 32, 240) | |
| # self.current_image_rgb[int(box_x_center), int(box_y_center+1)]= (160, 32, 240) | |
| # self.current_image_rgb[int(box_x_center), int(box_y_center+2)]= (160, 32, 240) | |
| # Then need to index into the depth image class variable saved as self.depth_image with the x,y coordinates | |
| # And then print out the pixel value | |
| ##TODO: make sure that y-center and x-center are not out of bounds (return nothing if out of bounds) | |
| if not self.depth_image is None: | |
| print(type(self.depth_image)) | |
| print(f"The boxcenterx variable is {int(box_x_center)}") | |
| print(f"The boxcentery variable is {int(box_y_center)}") | |
| print(f"The pixel value at the box location is hopefully {self.depth_image[int(box_y_center), int(box_x_center)]}") | |
| # print(type(self.depth_image[int(box_x_center)][int(box_y_center)])) | |
| msg = Float32() | |
| msg.data = (self.depth_image[int(box_y_center + 50), int(box_x_center + 30)].item()) / 1000 | |
| # msg.data = int(box_x_center) | |
| self.buoy_depth_pixel_pub.publish(msg) | |
| # generate purple boxes around the center of the detected buoy | |
| for x_value in range(self.current_image_rgb.shape[1]): | |
| for y_value in range(self.current_image_rgb.shape[0]): | |
| difference_vector = [abs(y_value - int(box_y_center)), abs(x_value - int(box_x_center))] | |
| max_value = max(difference_vector[0], difference_vector[1]) | |
| if max_value <= 20: | |
| self.current_image_rgb[y_value, x_value] = [160, 32, 240] | |
| # cv2.imwrite("rgb_image.jpg", self.current_image_rgb) | |
| result.save("rgb_image.png") | |
| # For Depth Image | |
| # for x_value in range(self.depth_image.shape[1]): | |
| # for y_value in range(self.depth_image.shape[0]): | |
| # difference_vector = [abs(y_value - int(box_y_center + 50)), abs(x_value - int(box_x_center + 30))] | |
| # max_value = max(difference_vector[0], difference_vector[1]) | |
| # if max_value <= 20: | |
| # self.depth_image[y_value, x_value] = 0 | |
| # cv2.imwrite("depth_image.jpg", self.depth_image) | |
| if SHOULD_SAVE_IMAGES: | |
| print("GOT HERE") | |
| result.save(f"cv_results2/result_{self.image_to_save_index}.png") # display to screen | |
| self.image_to_save_index += 1 | |
| # TODO process these results properly | |
| # self.object_detection_results_publisher.publish() | |
| def main(): | |
| rclpy.init() | |
| buoy_detection_node = BuoyDetectionNode() | |
| rclpy.spin(buoy_detection_node) | |
| if __name__ == "__main__": | |
| main() | |