Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· openaiHugging Face Suzhen/CodeChat

import cv2 import numpy as np import pyautogui Wczytaj obrazek marchewki carrotimg =…

  1. User

    import cv2 import numpy as np import pyautogui

    Wczytaj obrazek marchewki

    carrot_img = cv2.imread('marchewka.png')

    Funkcja do wyszukiwania elementów na ekranie na podstawie obrazka

    def find_image_on_screen(image): screen_image = pyautogui.screenshot() screen_np = np.array(screen_image) screen_gray = cv2.cvtColor(screen_np, cv2.COLOR_BGR2GRAY) image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    result = cv2.matchTemplate(screen_gray, image_gray, cv2.TM_CCOEFF_NORMED)
    min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)
    
    threshold = 0.8  # Dopasowanie powyżej tej wartości będzie uznane za trafienie
    
    if max_val >= threshold:
        # Znaleziono dopasowanie
        image_width, image_height = image.shape[:-1]
        top_left = max_loc
        bottom_right = (top_left[0] + image_width, top_left[1] + image_height)
        return (top_left, bottom_right)
    
    return None
    

    carrot_location = find_image_on_screen(carrot_img) if carrot_location is not None: # Znaleziono marchewkę na ekranie print("Znaleziono marchewkę!") print("Lokalizacja: Top left:", carrot_location[0], "Bottom right:", carrot_location[1]) center_x = (carrot_location[0][0] + carrot_location[1][0]) // 2 center_y = (carrot_location[0][1] + carrot_location[1][1]) // 2 pyautogui.moveTo(center_x, center_y) else: print("Nie znaleziono marchewki.")

    Moja marchewka znajduje się na szarym tle a obecny kod wykrywa marchewkę tam gdzie jej nie ma ale jest szare tło, jak to naprawić?

  2. Assistant

    Jest kilka rzeczy, które można tu zrobić, aby poprawić wykrywanie marchewki na ekranie, mimo obecności szarych tła:

    1. Użyj algorytmu dopasowania do wzoru, który jest mniej podatny na podobieństwo kolorów, jak SIFT lub SURF, zamiast używać szaro-skalowego dopasowania.

    2. Możesz stworzyć funkcję lub klasy, które zachowują stan wykrywanej marchewki i filtrują fałszywe pozytywy na podstawie poprzedniego położenia marchewki. W przypadku, gdy marchewka przesuwa się w ruchu, możesz stworzyć śledzenie średnie i odchylenie standardowe prędkości dla odrzucenia obiektów o prędkosiach, które nie spełniają kryterium.

    Oto zmodyfikowany kod używający dezygnacji przytulania do wykrywania marchewki na podstawie funkcji SIFT.

    import cv2
    import numpy as np
    import pyautogui
    
    carrot_img = cv2.imread('marchewka.png')
    
    def find_image_on_screen(image):
        screen_image = pyautogui.screenshot()
        screen_np = np.array(screen_image)
        screen_gray = cv2.cvtColor(screen_np, cv2.COLOR_BGR2GRAY)
        image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        
        sift = cv2.SIFT_create()
        
        kp1, des1 = sift.detectAndCompute(image_gray, None)
        kp2, des2 = sift.detectAndCompute(screen_gray, None)
    
        bf = cv2.BFMatcher()
        matches = bf.knnMatch(des1, des2, k=2)
    
        good_matches = []
        for m, n in matches:
            if m.distance < 0.75 * n.distance:
                good_matches.append(m)
    
        if len(good_matches) > 10:  # Wartość progowa przypadków dobrego dopasowania
            src_pts = np.float32([kp1[m.queryIdx].pt for m in good_matches]).reshape(-1,1,2)
            dst_pts = np.float32([kp2[m.trainIdx].pt for m in good_matches]).reshape(-1,1,2)
    
            M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
            matchesMask = mask.ravel().tolist()
    
            h, w = image_gray.shape
            pts = np.float32([[0, 0], [0, h-1], [w-1, h-1], [w-1, 0]]).reshape(-1,1,2)
            dst = cv2.perspectiveTransform(pts, M)
    
            screen_np = cv2.polylines(screen_np, [np.int32(dst)], True, 255, 3, cv2.LINE_AA)
            
            top_left = (dst[0][0][0], dst[0][0][1])
            bottom_right = (dst[2][0][0], dst[2][0][1])
    
            return (top_left, bottom_right)
        
        return None
    
    carrot_location = find_image_on_screen(carrot_img)
    if carrot_location is not None:
        print("Znaleziono marchewkę!")
        print("Lokalizacja: Top left:", carrot_location[0], "Bottom right:", carrot_location[1])
        center_x = (carrot_location[0][0] + carrot_location[1][0]) // 2
        center_y = (carrot_location[0][1] + carrot_location[1][1]) // 2
        pyautogui.moveTo(center_x, center_y)
    else:
        print("Nie znaleziono marchewki.")
    

    Warto zauważyć, że metoda SIFT może działać wolniej niż metoda cv2.matchTemplate. Można eksperymentować z różnymi metodami dopasowania lub parametrami, aby uzyskać optymalne wyniki dla swojego przypadku. SILT można zamienić na SURF, jesli potrzebujesz większa szybkość obliczeń. Jeśli jakość tła nie zmienia się, możesz wykorzystać tło, które jest zepsute do rozsądnej wartości musi oszacowane kosztem wykrywalności marchewek.

  3. User

    Teraz napisz kod który ma dostarczone 2 screeny gdzie na jednym znajduje się ekwipunek z gry minecraft z pszenicą a drugi bez a gdy wysle mu 3 obrazek bez lub z to napisze czy jest z czy bez

  4. Assistant

    W tym przypadku użyję SIFT w celu wykrycia pszenicy na ekranie. Poniżej znajduje się kod:

    import cv2
    import numpy as np
    
    def find_image_on_screen(image_template, screen_image):
        screen_gray = cv2.cvtColor(screen_image, cv2.COLOR_BGR2GRAY)
        image_gray = cv2.cvtColor(image_template, cv2.COLOR_BGR2GRAY)
        
        sift = cv2.SIFT_create()
        
        kp1, des1 = sift.detectAndCompute(image_gray, None)
        kp2, des2 = sift.detectAndCompute(screen_gray, None)
    
        bf = cv2.BFMatcher()
        matches = bf.knnMatch(des1, des2, k=2)
    
        good_matches = []
        for m, n in matches:
            if m.distance < 0.75 * n.distance:
                good_matches.append(m)
    
        if len(good_matches) > 20:  # Wartość progowa przypadków dobrego dopasowania
            return True
        
        return False
    
    # Wczytaj obrazy
    wheat_img = cv2.imread('pszenica.png')
    screen_with_wheat = cv2.imread('ekran_z_pszenica.png')
    screen_without_wheat = cv2.imread('ekran_bez_pszenica.png')
    
    # Sprawdź, czy obrazek ma pszenicę
    has_wheat_with = find_image_on_screen(wheat_img, screen_with_wheat)
    has_wheat_without = find_image_on_screen(wheat_img, screen_without_wheat)
    
    if has_wheat_with:
        print("Ekran 'ekran_z_pszenica.png' zawiera pszenicę.")
    else:
        print("Ekran 'ekran_z_pszenica.png' nie zawiera pszenicy.")
    
    if has_wheat_without:
        print("Ekran 'ekran_bez_pszenica.png' zawiera pszenicę.")
    else:
        print("Ekran 'ekran_bez_pszenica.png' nie zawiera pszenicy.")
    

    W powyższym kodzie używam funkcji find_image_on_screen, która przyjmuje obraz szablonu (w tym przypadku obraz pszenicy) i obraz ekranu, na którym należy sprawdzić obecność pszenicy. Funkcja zwraca True, jeśli na ekranie wykryto pszenicę, w przeciwnym razie zwraca False.

    Następnie wczytuję obrazy: obraz szablonu pszenicy oraz dwa ekrany (jeden z pszenicą i jeden bez niej) i sprawdzam, czy pszenica jest obecna na każdym z nich.

    Musisz zastąpić nazwy plików obrazów oraz wartość progową we funkcji find_image_on_screen odpowiednimi wartościami dla swoich przypadków.

    Jeżeli otrzymasz niewłaściwe wyniki, spróbuj dostosować wartość progową. Można również przejść na inne metody dopasowania, takie jak ORB, SURF lub inne, w celu uzyskania lepszych wyników.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.