A função cv2.matchTemplate falha na correspondência

Isso significaria que a função de correspondência se concentra apenas na bola e não em qualquer ruído de fundo.
Mas você também deve converter o modelo em tons de cinza para torná-lo mais distinguível. Você pode ver isso feito em " Tutoriais OpenCV-Python/Processamento de imagens em OpenCV/Template Matching " template_gray = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY):.
Em seguida, determine manualmente a caixa delimitadora da bola e recorte o modelo : cropped_template = template_gray[y:y+h, x:x+w].

OpenCVsmatchTemplate podem usar uma máscara como argumento opcional , o que indica para considerar apenas as partes brancas da máscara durante o processo de correspondência.

Assim você pode criar uma máscara para o modelo recortado, e passá-la matchTemplatepara considerar apenas a bola durante o processo de correspondência: mask = np.zeros(cropped_template.shape, dtype=np.uint8)
Use numpy.zeros: `` Irá criar um array de zeros com as mesmas dimensões que template_gray(que representa a imagem do modelo convertida para tons de cinza ).

Desenhe um círculo branco na máscara onde a bola está localizada:
cv2.circle(mask, (mask.shape[1]//2, mask.shape[0]//2), radius, 255, -1)

radiusdeve ser definido com um valor que corresponda ao tamanho do objeto de interesse na imagem do modelo, e a circlefunção preencherá o círculo com o valor 255, criando uma área branca na máscara.

Seu código seria:

import cv2
import numpy as np
import matplotlib.pyplot as plt

template = cv2.imread("path_to_cropped_template.jpg")
template_gray = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY)

x, y, w, h = 100, 100, 50, 50  # Replace with actual values
cropped_template = template_gray[y:y+h, x:x+w]

# Create a mask for the cropped template
mask = np.zeros(cropped_template.shape, dtype=np.uint8)
cv2.circle(mask, (w//2, h//2), w//2, (255), -1)

search_img = cv2.imread("path_to_search_image.jpg")
search_img_gray = cv2.cvtColor(search_img, cv2.COLOR_BGR2GRAY)

res = cv2.matchTemplate(search_img_gray, cropped_template, cv2.TM_CCOEFF_NORMED, mask=mask)
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)

top_left = max_loc
bottom_right = (top_left[0] + w, top_left[1] + h)
cv2.rectangle(search_img, top_left, bottom_right, 255, 2)

plt.imshow(cv2.cvtColor(search_img, cv2.COLOR_BGR2RGB))
plt.show()

Novamente, x, y, w, hna seção de corte devem estar as coordenadas e o tamanho da bola dentro da imagem real do modelo.

Você pode adicionar non_max_suppressionse o modelo aparecer várias vezes na imagem de pesquisa:

import cv2
import numpy as np
import matplotlib.pyplot as plt
from imutils.object_detection import non_max_suppression

template = cv2.imread('path_to_cropped_template.jpg', cv2.IMREAD_COLOR) 
img = cv2.imread('path_to_search_image.jpg', cv2.IMREAD_COLOR)

template_gray = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY)
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

mask = np.zeros(template_gray.shape, dtype=np.uint8)
cv2.circle(mask, (mask.shape[1] // 2, mask.shape[0] // 2), mask.shape[1] // 2, 255, -1)

h, w = template_gray.shape[:2]

# Match template using the mask
res = cv2.matchTemplate(img_gray, template_gray, cv2.TM_CCOEFF_NORMED, mask=mask)
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)

# If the method is TM_SQDIFF or TM_SQDIFF_NORMED, take minimum
top_left = min_loc if res.min() == min_val else max_loc
bottom_right = (top_left[0] + w, top_left[1] + h)

cv2.rectangle(img, top_left, bottom_right, (255, 0, 0), 2)

# Apply non-maximum suppression to the bounding boxes
rects = [[*top_left, *bottom_right]]
pick = non_max_suppression(np.array(rects))

for (startX, startY, endX, endY) in pick:
    cv2.rectangle(img, (startX, startY), (endX, endY), (0, 255, 0), 2)

plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.title('Detected Point')
plt.show()

Isto não pode ser resolvido através da correspondência de modelos. você tem diferentes visualizações de um objeto 3D.

Concordo: a correspondência de modelos geralmente é adequada para padrões de imagens 2D que não mudam de perspectiva ou forma. Seria assumido que o modelo e a parte da imagem que está sendo pesquisada são orientados e dimensionados de forma semelhante.
Quando o objeto em questão é tridimensional, como uma bola de futebol, e as imagens o capturam de diferentes ângulos ou sob diferentes condições de iluminação, a aparência do modelo pode mudar devido a distorções de perspectiva, mudanças de iluminação e oclusões.

Você pode tentar uma combinação de correspondência de modelo em várias escalas e uma máscara, que seria mais robusta do que a simples correspondência de modelo, mas ainda não seria uma solução abrangente para combinar imagens de objetos 3D que podem parecer muito diferentes devido à rotação, perspectiva mudanças e outros fatores.

import cv2
import numpy as np
import matplotlib.pyplot as plt

def multi_scale_template_matching_with_mask(search_img, template, template_mask, scale_steps=20, method=cv2.TM_CCOEFF_NORMED):
    h, w = template.shape[:2]
    # keep track of the most accurate matching
    found = None

    search_img_gray = cv2.cvtColor(search_img, cv2.COLOR_BGR2GRAY)
    template_gray = cv2.cvtColor(template, cv2.COLOR_BGR2GRAY)

    for scale in np.linspace(0.2, 1.0, scale_steps)[::-1]:
        # Resize the image according to the scale, and keep track of the ratio of the resizing
        resized = cv2.resize(search_img_gray, None, fx=scale, fy=scale, interpolation=cv2.INTER_AREA)
        r = search_img_gray.shape[1] / float(resized.shape[1])

        # If the resized image is smaller than the template, then break from the loop
        if resized.shape[0] < h or resized.shape[1] < w:
            break

        # Apply template Matching with the mask
        result = cv2.matchTemplate(resized, template_gray, method, mask=template_mask)

        _, max_val, _, max_loc = cv2.minMaxLoc(result)

        if method in [cv2.TM_SQDIFF, cv2.TM_SQDIFF_NORMED]:
            matchLoc = min_loc
        else:
            matchLoc = max_loc

        # If we have found a new maximum correlation value, then update the bookkeeping variable
        if found is None or max_val > found[0]:
            found = (max_val, matchLoc, r)

    # Unpack the bookkeeping variable and compute the (x, y) coordinates of the bounding box
    _, max_loc, r = found
    start_x, start_y = int(max_loc[0] * r), int(max_loc[1] * r)
    end_x, end_y = int((max_loc[0] + w) * r), int((max_loc[1] + h) * r)

    cv2.rectangle(search_img, (start_x, start_y), (end_x, end_y), (255, 0, 0), 2)

    plt.imshow(cv2.cvtColor(search_img, cv2.COLOR_BGR2RGB))
    plt.show()

search_img = cv2.imread('path_to_search_image.jpg')
template = cv2.imread('path_to_template.jpg')
template_mask = cv2.imread('path_to_template_mask.jpg', 0)  # Assuming the mask is a grayscale image

multi_scale_template_matching_with_mask(search_img, template, template_mask)

Ele multi_scale_template_matching_with_masktentará encontrar o modelo na imagem de pesquisa em diferentes escalas enquanto usa uma máscara para focar a correspondência em características específicas do modelo (por exemplo, a bola).