Cet article est un article de relais du "Calendrier de l'Avent du Nouvel An 2020 TechConnect!" de Link Information System est. TechConnect! Est un calendrier de l'Avent à démarrage automatique qui est relayé par un groupe autodidacte appelé engineer.hanzomon. (Depuis Facebook here du système d'information sur les liens)

Puisque le thème était gratuit, ce sera un article gratuit. (La technologie utilisée est sérieuse.) J'ai pleinement utilisé le didacticiel et j'ai fait de mon mieux pour reconnaître l'image.

Ce qui a été fait

Un programme pour le jugement Win / Lose de Shadowverse (version Steam) a été créé. ダウンロード.gif (L'écran gif est dessiné pour confirmer le jugement perdant. Le jugement peut être fait sans dessin.)

Comme vous pouvez le voir, il ne s'agit que d'une comparaison entre l'image Win / Lose et l'écran de capture. "Déterminez en temps réel si une image spécifiée apparaît dans la capture d'une application spécifique" Je pense que ce sera une référence pour ceux qui veulent faire quelque chose.

Ce que j'ai utilisé

Python 3.7.4
pip 19.3.1
numpy 1.17.3
opencv-contrib-python 4.1.1.26
Pillow 6.2.0

Veuillez vous référer à l'article de référence ci-dessous pour la méthode d'installation. Je pourrais simplement l'installer avec un pip à une extrémité, donc il n'y avait rien de particulièrement obstrué.

manière

Capture d'écran de l'écran de jeu
Comparez l'image capturée avec l'image Win / Lose
Coupez les points d'entité avec Distance, et si l'entité pointe au-dessus d'un certain niveau correspond, elle est considérée comme Win / Lose.
Si le jugement Win / Lose est continu plus d'un certain nombre de fois, il est jugé comme écran Win / Lose.

Capture d'écran de l'écran de jeu

J'ai capturé en utilisant PIL en me référant à l'article suivant. [Python] [Windows] Capture d'écran en Python

from PIL import ImageGrab
import numpy as np

TARGET_NAME = 'Shadowverse'
handle = win32gui.FindWindow(None, TARGET_NAME)

while True:
    rect = win32gui.GetWindowRect(handle)
    img = ImageGrab.grab(rect)
    ocv_im = np.asarray(img)

    #Conversion de couleur pour OpenCV
    ocv_im = cv2.cvtColor(ocv_im, cv2.COLOR_BGR2RGB)

    #Dessiner à l'écran (pour confirmation)
    cv2.imshow("images", ocv_im, )

    #Appliquer Attendre par une méthode appropriée (sécurisation du temps de dessin)
    cv2.waitKey(10)

Comparez l'image capturée avec l'image Win / Lose

(L'image Win / Lose est recadrée à partir de la capture d'écran à l'avance.)

Reportez-vous aux articles suivants et effectuez une correspondance de quantité de fonctionnalités avec AKAZE. Correspondance de la quantité de fonctionnalités avec OpenCV 3 et Python 3 (A-KAZE, KNN)

def MatchResultCheck(ocv_img):
    win_img = cv2.imread(WIN_IMAGE_PATH)
    lose_img = cv2.imread(LOSE_IMAGE_PATH)

    akaze = cv2.AKAZE_create()

    kp2, des2 = akaze.detectAndCompute(ocv_img, None)
    kp1_l, des1_l = akaze.detectAndCompute(lose_img, None)
    kp1_w, des1_w = akaze.detectAndCompute(win_img, None)

    is_win = False
    is_lose = False

    bf = cv2.BFMatcher()
    if not des2 is None :
        #Correspondance des fonctionnalités entre l'image perdue et l'image capturée
        matches_l = bf.knnMatch(des1_l,des2, k=2)
        #Correspondance des fonctionnalités entre l'image Win et l'image capturée
        matches_w = bf.knnMatch(des1_w,des2, k=2)

        #Perdre le jugement
        good_l = []
        for match1, match2 in matches_l:
            if match1.distance < 0.75*match2.distance:
                good_l.append([match1])
        #Gagner le jugement
        good_w = []
        for match1, match2 in matches_w:
            if match1.distance < 0.75*match2.distance:
                good_w.append([match1])

        #Créer une image pour confirmation
        akaze_matches = cv2.drawMatchesKnn(lose_img,kp1_l,ocv_img,kp2,good_l,None,flags=2) 
        #Dessiner à l'écran (pour confirmation)
        cv2.imshow("match", akaze_matches, )

        if len(good_l) > 20 :
            print("is lose")
            is_lose = True

        if len(good_w) > 20 :
            print("is win")
            is_win = True

    return is_win, is_lose

Gagner / perdre le jugement

La distance (à quel point elle correspond) est stockée dans le résultat de la correspondance, donc coupée avec Distance.

        #Perdre le jugement
        good_l = []
        for match1, match2 in matches_l:
            #Extraire uniquement les points caractéristiques avec une certaine distance ou plus
            if match1.distance < 0.75*match2.distance:
                good_l.append([match1])

S'il y a plus d'un certain nombre de points caractéristiques après la coupe, il est jugé que l'image Win / Lose existe.

        if len(good_l) > 20 :
            print("is lose")
            is_lose = True

Gagner l'écran / perdre le jugement d'écran

Afin de supprimer les faux positifs, l'écran Win / Lose est jugé uniquement lorsqu'il est jugé comme une image Win / Lose plus d'un certain nombre de fois de suite. (Puisque j'utilise python, je pense que je peux l'écrire plus simplement ...)

    is_win, is_lose = MatchResultCheck(ocv_im)

    if is_lose :
        cnt_lose_match += 1
        if cnt_lose_match >= 4:
            print("is lose match")
            cnt_lose_match = 0
            cv2.waitKey(1000)
    else :
        cnt_lose_match = 0

Ce que je n'ai pas pu faire

Jugons la première attaque / deuxième attaque de la même manière! Je pensais que je ne pouvais pas bien le faire ... Contrairement à Win / Lose, l'image du jugement est trop petite et je me demande si le kanji est douloureux. Je continuerai à me consacrer.

Résumé

J'ai pu déterminer si une image particulière était présente dans la capture d'écran. Il serait intéressant de pouvoir tirer les résultats du jugement en temps réel.

La prochaine fois, c'est @ rysk001.

[PYTHON] Juger la victoire ou la défaite de Shadova par reconnaissance d'image