[JAVA] Discrimination d'image d'icône Pokemon à l'aide des fonctionnalités HOG
Objectif
- Il existe différents outils de journal de combat Pokémon, mais il est trop fastidieux de devoir saisir le contenu de l'autre partie par moi-même, donc je voulais créer quelque chose qui le déterminerait automatiquement.
- Je voulais utiliser la quantité de fonctionnalités HOG.
Les mises en œuvre sont au bas de l'article.
- Cette version est destinée aux écrans affichés sur les moniteurs utilisant de faux Toro Capture.
À propos des fonctionnalités HOG
HOG (Histgram Of Gradient) est comme la distribution des gradients de luminosité dans une image. Étant donné que vous pouvez détecter où la luminosité change de manière significative, vous pouvez obtenir approximativement la distribution des bords de l'image. L'explication de ici était facile à comprendre.
Exprimé sous forme d'image
Je me sens comme cela.
(La source de l'image est les images debout des sœurs Kotoba (30 types chacune))
- La couleur d'arrière-plan des données disponibles et la couleur d'arrière-plan sur l'écran de jeu à distinguer sont différentes.
- Sur l'écran de jeu, la couleur d'arrière-plan diffère selon la position.
Il est particulièrement important cette fois qu'il soit difficile d'être influencé par ces deux points.
La méthode d'extraction HOG est implémentée dans diverses bibliothèques. Dans la gamme j'ai essayé
--scikit-image porc --OpenCV (pour Python) Descripteur HOG --OpenCV (pour java) HOGDescriptor
J'ai essayé trois types. Terriblement ** Les méthodes implémentées dans ceux-ci renverront des résultats différents (seul le nombre de dimensions est égal) **. Le contour de l'algorithme est le même, mais il semble que l'implémentation détaillée telle que la procédure de calcul soit différente.
algorithme
Aperçu de la procédure
- Extraction de cadres de fête à partir d'images
- Découpez la partie icône Pokemon de la partie cadre de fête
- Estimation du nom de chaque partie de l'icône
Extraction de machines à sous
Il suffit de saisir le bord avec le filtre Canny et de creuser l'intérieur. C'est presque ceci.
L'image originale
Image d'extraction de bord
Recadrer l'image
- Le nom du formateur a été refusé pour le moment
Découpez la partie icône
Étant donné que l'emplacement de la partie d'image d'icône dans le cadre est fixe, tout ce que vous avez à faire est de déterminer la position et de la découper. Je l'ai ajusté de manière appropriée tout en expérimentant.
Vous pouvez obtenir une image comme celle-ci.
Estimation de nom à l'aide des fonctionnalités HOG
- Divisez l'image 30x30 en 3 canaux de couleur de BGR
- Supprimez le bruit avec un filtre gaussien pour chaque image
- Calculez le HOG avec une taille de cellule de 5 pixels et une taille de bloc de 30 pixels (6 cellules) (324 dimensions)
- Combinez les HOG pour 3 couleurs dans un vecteur de 972 dimensions
- Calculez la distance de Manhattan à partir du vecteur extrait de manière similaire pour chaque image d'enseignant
- L'image avec la distance la plus proche est la bonne réponse
J'ai essayé plusieurs types de taille de cellule et de taille de bloc, mais cette combinaison était bonne. Pour bien utiliser cette combinaison, la taille de l'image de jugement est définie sur 30x30. Je vais coller le code Python (partie estimée). La première version collée étant ancienne, je n'ai remplacé que les hyper paramètres utilisés pour le calcul HOG (2017/3/4)
estimate.py
#Une méthode pour estimer le nom Pokemon. Les données d'argument sont une paire de nom Pokemon et son HOG.
def estimate_poke_index(image, data):
hog = calculateHOG(image)
distance_list = calculate_manhattan_distance(hog, data)
return np.argmin(np.array(distance_list))
#Une méthode qui lit une image, calcule et renvoie les fonctionnalités HOG
def calculateHOG(image, orient=9, cell_size=5, block_size=6):
#Charger l'image
number_color_channels = np.shape(image)[2]
if number_color_channels > 3:
mask = image[:, :, 3]
image = image[:, :, :3]
for i in range(len(mask)):
for j in range(len(mask[0])):
if mask[i][j] == 0:
image[i, j, :] = 255
#Redimensionner l'image à 30x30
resized_image = cv2.resize(image, (30, 30))
images = cv2.split(resized_image)
fd = []
for monocolor_image in images:
blur_image = cv2.GaussianBlur(monocolor_image, (3,3),0)
fd.extend(hog(blur_image, orientations=orient,
pixels_per_cell=(cell_size, cell_size), cells_per_block=(block_size, block_size)))
return fd
#Méthode de calcul de la distance entre les entités HOG
def calculate_distance_HOG(target, data):
distance_list = []
rows, columns = np.shape(data)
for i in range(rows):
distance_list.append(np.linalg.norm(data[i, :] - target))
return distance_list
#Méthode de calcul de la distance de Manhattan
def calculate_manhattan_distance(target, data):
distance_list = []
rows, columns = np.shape(data)
for i in range(rows):
distance_list.append(np.sum(np.abs(data[i, :] - target)))
return distance_list
Impressions
Bien qu'il s'agisse d'un algorithme approximatif, vous pouvez faire l'expérience de 70 à 80%. Ce serait bien si je pouvais écrire sur les résultats des tests, mais j'ai bien peur de ne pas avoir fait de test cohérent. (PostScript 2017/3/4) Lorsque j'ai obtenu les données pour 19 jeux et vérifié le taux de méconnaissance, j'ai fait une erreur avec 20/114. Il semble qu'environ 80% peuvent être devinés, mais je voudrais gérer la méconnaissance de Pokémon avec un KP élevé tels que "Gekkouga → Fukuslow" et "Garula → Chilt".
- De couleur et de forme similaires (Gabite et Gabrias, etc.)
- Les Pokémon avec de petites icônes (Garula, Lucario, Metamon, Lucky, etc.) sont placés plus près du coin inférieur droit que prévu.
Deux sont probablement les principales idées fausses. La seconde peut être correcte si l'algorithme est légèrement amélioré.
Bien que ce soit pour les développeurs d'outils, je vais mettre implémenté et renforcé en Java. Vous pouvez l'utiliser librement, mais je serais heureux si vous pouviez me le faire savoir. (Parce que je veux aller voir le produit fini)