Identificação do campo

Código que implementa a delimitação do campo

field_delimited = False

# Transformation matrix for the homography

M = None

max_width = None

max_height = None

# Relevant corners for the homography

corners, ids = None, None

top_left_corner = None

bottom_right_corner = None

top_right_corner = None

bottom_left_corner = None

# Configuring the ArUco detector

aruco_dict = cv2.aruco.getPredefinedDictionary(cv2.aruco.DICT_6X6_250)

parameters =  cv2.aruco.DetectorParameters()

detector = cv2.aruco.ArucoDetector(aruco_dict, parameters)

ax.set_title("Identifying the ArUcos", color='gray', fontsize=10)

while not field_delimited:

    succes, frame = cap.read()

    # Undistorting the frame from the camera

    dst = cv2.undistort(frame, cameraMatrix, dist, None, newCameraMatrix)

    frame = dst[roi[1]:roi[1]+roi[3], roi[0]:roi[0]+roi[2]]

    output_frame = dst.copy()

    # First we make the image monochromatic

    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # Then we detect the arucos

    corners, ids, rejectedImgPoints = detector.detectMarkers(gray)

    frame_markers = cv2.aruco.drawDetectedMarkers(frame.copy(), corners, ids)

    corners = np.array(corners, dtype=int)

    # We now check if the amount of detected ArUcos is the expected one

    # If it is not, the detection failed

    if len(corners) == 4:

        field_delimited = True

        # The top left corner is identified by the Aruco with ID = 0

        top_left_corner_id = np.where(ids == 0)[0]

        # The bottom right corner is identified by the Aruco with ID = 2

        bottom_right_corner_id = np.where(ids == 2)[0]

        # The bottom right corner is identified by the Aruco with ID = 3

        top_right_corner_id = np.where(ids == 3)[0]

        # The bottom right corner is identified by the Aruco with ID = 1

        bottom_left_corner_id = np.where(ids == 1)[0]

        top_left_corner = corners[top_left_corner_id][0][0][0]

        bottom_right_corner = corners[bottom_right_corner_id][0][0][0]

        top_right_corner = corners[top_right_corner_id][0][0][0]

        bottom_left_corner = corners[bottom_left_corner_id][0][0][0]

        width_top = np.hypot(

            top_left_corner[0] - top_right_corner[0],

            top_left_corner[1] - top_right_corner[1])

        width_bottom = np.hypot(

            bottom_left_corner[0] - bottom_right_corner[0],

            bottom_left_corner[1] - bottom_right_corner[1])

        max_width = max(int(width_top), int(width_bottom))

        height_left = np.hypot(

            top_left_corner[0] - bottom_left_corner[0],

            top_left_corner[1] - bottom_left_corner[1])

        height_right = np.hypot(

            top_right_corner[0] - bottom_right_corner[0],

            top_right_corner[1] - bottom_right_corner[1])

        max_height = max(int(height_left), int(height_right))

        input_pts = np.float32([top_left_corner,

                                bottom_left_corner,

                                bottom_right_corner,

                                top_right_corner])

        output_pts = np.float32([[0, 0],

                                [0, max_height - 1],

                                [max_width - 1, max_height - 1],

                                [max_width - 1, 0]])

        pixel_density = max_height/field_lenght_m

        # Compute the perspective transform M

        M = cv2.getPerspectiveTransform(input_pts,output_pts)

    output_frame = cv2.cvtColor(frame_markers, cv2.COLOR_BGR2RGB)

# Compute the perspective transform IM to transforme the image back

_, IM = cv2.invert(M)