Analyse d'une image Fermé

Question

Bonjour,  

J'ai mon premier programme à réaliser en  python pour mes études, le soucis c'est que je suis vraiment nul, très nul en programmation. 

Donc j'aurais aimé savoir s'il est possible d'avoir un coup de main ici. 

Je vous explique le sujet, déjà on passe par jupyter notebook que j'ai installer via anaconda il me semble. Le prof nous a transmis un jeu de carte via un dossier mais le souci premièrement c'est que dès que je change la valeur de la carte (D'un 10 de trèfle je veux afficher un 10 de coeur) et ben ça ne fonctionne pas. Surement un soucis de réglages mais je ne comprends pas quoi. 

Du coup, le sujet c'est qu'à partir d'une analyse de l'image, on doit savoir reconnaître qu'elle carte est affiché à l'écran. Le jeu de carte que l'on doit étudier est un jeu de carte basique sauf que l'on prend que les cartes de 1 à 10, on exclu les figures. 

A partir de là, il faut être capable d'identifier:

La couleur: noire ou rouge
La forme:  coeur, carreau, trèfle ou pique 
Le numéro: donc de 1 à à10. 

 

Donc selon moi il faudrait réaliser une analyse de l'image pixel par pixel avec la bibliothèque matpotlib de ce que j'ai  pu trouvé sur internet. 

Mon "algorithme" commencerait par quelque chose comme ça (je me répète, mais le développement j'y arrive absolument pas): 

Pour "pixel" allant de 1 à "nombre de pixel total" faire: 
     n° pixel <- Valeur rgb (ce qui nous donnerait la liste de tous les pixels avec la couleur, donc la 
     couleur serait déjà trouvé) 

Ensuite je pense qu'il  faudrait comparer le nombre de pixels blanc par rapport au nombre de pixels noir ou rouge. Car plus il y a de la couleur sur la carte, plus le chiffre sur la carte est élevé.  Mais là je n'ai aucunes approche de comment je pourrait faire. Avec cette partie on  pourrait en déduire le chiffre. 

Et pour la forme il faudrait, selon moi, analyser un pixel spécifique je m'explique. Sur chaque carte il y a le symbole qui est placé au même endroit sur la carte (dans les 4 coins). Donc grossièrement si on analyse une carte rouge, les pixels du coeur seront différents des pixels du carreau. 

Selon vous est ce une première bonne approche ? 

Je ne souhaite pas quelqu'un qui fasse le programme pour moi évidemment, mais de l'aide et une piste sur laquelle je peux m'appuyer. 

J'espère avoir été clair, et je vous remercie d'avoir pris le temps de lire et de m'aider si c'est possible. 

Bonne journée à vous


Configuration: Windows / Chrome 86.0.4240.75

Phil_1857 · Answer

Bonjour Terence,


Si j'ai bien compris:

_ Tu débutes en programmation ?

_ Le prof vous a donné des images d'un jeu de cartes ?

_ Il vous demande vraiment de faire de la reconnaissance d'image ?


Pour débuter, il me semble qu'il y a des exercices plus faciles !

C'est vraiment ça ?

Terence · Answer

Bonjour Phil, 

Oui c’est ça. Après dans ma classe certains sont déjà avancé en programmation, ce qui n’est pas mon cas. C’est pour ça qu’il a dit qu’il ne mettait que les cartes de 1 à 10. 

Il nous a bien fourni un jeu de carte en image oui. 

D’après lui c’est très simple et basique comme genre de code

Phil_1857 · Answer

Je serais curieux de voir ce que ca donne ...

Pour moi, reconnaissance d'image = IA avec réseau de neurones et tout ...

quent217 · Answer

Bonjour,
Je vous avoue que je suis tout aussi étonné que Phil_1857 qu'on vous demande de faire de la reconnaissance d'image alors que vous débutez en programmation. Il s'agit à priori d'une tache d'intelligence artificielle donc c'est un sujet assez complexe.

Après le problème est peut-être plus simple que ce qu'il n'y parait, tout dépend des images qui vous ont été fournis. S'il s'agit de photos, alors je ne pourrais pas vous aider et je vous conseille de chercher des exercices plus facile pour commencer.
Si ce sont des images qui ont été généré numériquement, c'est à dire où tous les trèfles par exemple sont exactement les mêmes au pixel prêt et placés exactement au même endroit au pixel prêt, et si on ne vous demande pas que l'algorithme fonctionne pour des images inconnues, alors votre approche peut fonctionner. 

Pour le symbole, vous pouvez chercher quelques pixels qui vous permettent à partir de la couleur de ces seuls pixels, de trouver la couleur (pique, carreur, coeur trèfle) de la carte.

Pour déterminer le numéro de la carte, votre solution peut peut-être fonctionner, mais j'imagine que ça dépend de comment sont les images exactement. Si le numéro affiché est de la même couleur que les symboles, alors la surface du chiffre va être comptabilisée et pourra fausser les résultats. Mais encore une fois, ça dépends des images qui vous ont été données, rien de vous empêche d'essayer.

Sinon, une idée que j'ai, qui est plus compliqué, mais qui pourrait fonctionner dans le cas où votre première méthode ne fonctionnerait pas : vous pouvez faire comme pour l'analyse du symbole. Vous prennez quelques pixels qui vous permettent, à eux seuls, de déterminer le numéro de la carte. Si je prends un exemple avec uniquement des 1 et des 2, vous pouvez regarder le pixel au centre de la carte et les 2 pixels qui sont aux centre des symboles lorsque qu'il y en a 2, et en fonction des quels sont blancs, rouges, ou noirs, vous devriez pouvoir determiner s'il s'agit d'un 1 ou un 2.
Il faut généraliser ça avec les 10 numéros.

Bon, je ne sais pas ce que vous appellez débutant exactement.
Je ne trouve pas que ce soit un algorithme très simple quand même, mais étant donné que ça correspond plus ou moins à ce que vous avez proposé, je me dis que vous avez peut-être le niveau pour le réaliser. Ça reste quand même infiniment plus simple que de la "vrai" reconnaissance d'image.

T-Rence · Answer

Bonjour,

Merci pour vos réponses. 

Alors pour être plus clair, nous avons ce genre d'image . 

Et à partir de là il faut réaliser un code qui permettrait d'identifier la carte. 

Mon niveau en programmation est de 0. Je connais un peu les boucles etc mais niveau algorithmique. Lorsqu'il s'agit de traduire dans un langage j'ai beaucoup de mal. Je ne suis pas développeur mais malheureusement dans les études informatique on n'y échappe pas.

Phil_1857 · Answer

Bonjour T-rence,

Déjà, si il n'y a que les cartes de 1 à 10, cela simplifie le problème: il ne peut y avoir que 2 couleurs sur une carte, le blanc du fond et le rouge ou le noir des figures

Donc si les chiffres que tu affiches représentent les 3 composantes Rouge, Vert, Bleu de la couleur du pixel, tu peux chercher si il y a au moins 1 pixel rouge ou 1 noir, en dehors du blanc

Par contre, pour le type de figure, (trèfle, cœur,...), et le chiffre, c'est un peu moins simple ...

Pour le chiffre, on peut peut être compter la quantité de pixels noirs ou rouges, vu que sur le 10 de carreau, par exemple, il y a une surface de rouge plus grande que sur l'as

Moi je ferai d'abord un petit programme de test pour analyser les cartes une par une et donc récupérer le nombre de pixels de couleur de chacune, ce qui donnerait une liste de 10 entiers par figure qui servirait ensuite dans le programme définitif pour connaitre le chiffre d'une carte donnée
exemple : liste_trefle = [3250,4520,6585,8674, .....]

Exemple: tu a déterminé que c'est une carte rouge, et tu a le nb total de pixels rouges, donc tu cherches dans liste_carreau et dans liste_coeur un nb de pixels qui correspond 

Si le nb est le 5eme de la liste liste_carreau, c'est donc un 5 de carreau

T-Rence · Answer

Bonjour Phil, 

Merci pour ta réponse.

Oui voilà c'est à peu près le style d'idées que j'avais. Maintenant c'est surtout pour retranscrire en langage python qui va être compliqué. 

Est-ce que tu aurais des pistes vis-à-vis du code ? J'ai beau cherché sur le net mais je ne trouve pas vraiment de documentation qui ressemblerais à ce genre de choses. 

J'ai une assez bonne logique dans l'analyse mais dès qu'il s'agit d'être technique c'est un peu plus compliqué pour moi. 

Merci en tout cas de ton aide

Phil_1857 · Answer

for x in range(carte.width):
    for y in range(carte.height):
        print(pixel[x,y])


Avec ça, on analyse toute la surface

Ensuite, à toi de dire ce que représentent les chiffres qui s'affichent, personnellement, je ne connais ni 
numpy ni matplotlib, ni PIL ...

T-Rence · Answer

Les chiffres qui s'affichent (255 255 255 par exemple) représente les couleurs à un pixel donné. 255 255 255 étant le blanc et 0 0 0 le noir. 

Ok donc si je comprend ton code, on a deux boucles et chacune analyse un pixel sur la longueur et la largeur. 

A partir de ce moment là est- ce que l'on peut faire une "comparaison" ou une déduction qui serait: 
 Si au moins un pixel de la carte est rouge alors la carte est soit du carreau soit du coeur 
 Si non c'est soit du trèfle soit du pique ? 

Je sais pas si tu vois ce que je veux dire

Phil_1857 · Answer

"Ok donc si je comprend ton code, on a deux boucles et chacune analyse un pixel sur la longueur et la largeur."

on a 2 boucles pour extraire un pixel de coordonnées x,y, donc on parcourt toute la surface, dans ton exemple, tu ne parcours que la ligne en y 50

C'est quoi le 4eme chiffre qui s'affiche:

il n'y a pas que 255,255,255, mais un 4eme chiffre au bout ...

Enfin, si les 3 1ers chiffres sont la couleur, alors au lieu du print, on peut écrire:

noir = 0
rouge = 0
for x in range(carte.width):
    for y in range(carte.height):
        if(pixel[x,y][0:3] == (0,0,0)):
            noir += 1
        elif(pixel[x,y][0:3] == (255,0,0)):
            rouge += 1

En fin de boucle rouge = nb de pixels rouges et noir = nb de pixels noirs

015648974 · Answer

Fait un tableau avec les % de couleur de chaque carte en premier :
pctCouleurCarte = [0]*10

Tu devras remplir le tableau dans ton code quand tu auras récupérer le % de couleur de chaque carte 
Du coup avant d'avoir rempli les 10 valeurs, ton programme pourra juste te donner le % de couleur et pas trouver la carte

Rajoute avant ta boucle :
nbPixels = carte.width * carte.height

Après la boucle :
pctCouleur = (blanc / nbPixels) * 100

Quand ton tableau pctCouleurCarte est rempli :
for i in range (0,10) :
  if pctCouleurCarte[i] == pctCouleur
      print "La carte est la Carte " + i

T-Rence · Answer

Yes donc là je pense que grâce au code de Phil, je peux avoir l'info sur la couleur ce qui élimine une première étape du problème. 

Et grâce au tableau de pourcentage je peux avoir le numéro de la carte. 

Il me manquerait alors seulement la forme. Et là je pense qu'il faudrait superposer des pixels à partir d'une couleur. Quand on sait que c'est du rouge on superpose un même pixel sur une carte de carreau et de coeur et c'est ce qui nous donnerait la forme.

Phil_1857 · Answer

avec ma méthode, pas besoin de pourcentage, et il ne manque pas la forme

on obtient directement : 10 de trèfle, par exemple

(voir ma réponse de 15h43)

T-Rence · Answer

Bonjour, 


Je reviens vers vous pour le même problème. La solution a été acceptée, mais on m'a rajouté une contrainte qui serait si on zoom ou alors si on fait une rotation de la carte il faut que le programme la reconnaisse. 

Pour ça j'ai juste le droit d'utiliser des librairies qui permettent la rotation ou le zoom. 

Avec le code que l'on a déjà, je pense que pour la rotation ça ne devrait pas poser de soucis. Mais pour ce qui est du zoom je pense que le code ne fonctionnerait pas.

Merci pour votre aide

Phil_1857 · Answer

Bonjour T-Rence,


Tu veux dire que le zoom change le nombre de pixels

Si tu connais le facteur de zoom, tu multiplies le nombre de pixels (noirs ou rouges) trouvés sur 

la carte à tester par ce facteur et ca te donnes normalement une valeur de l'une des 4 listes

définies (pixels_trefle, etc ...)

Exemple: zoom = 2, on divise par 2, zoom = 0.5, on multiplie par 2

T-Rence · Answer

Bonjour Phil,

Merci de ta réponse et désolé de la mienne qui est un peu tardive j'ai été assez pris par le temps avec le travail ce week-end. 

Donc en gros si on connaît le coefficient multiplicateur pour le zoom il suffit de diviser le nombre de pixels par ce même coefficient ? 

J'ai peur que si on zoom que ce ne soit pas toute la carte qui soit zoomé mais juste une zone. Ce qui pourrait du coup fausser les résultats. 

Et est ce qu'il est possible de générer un zoom random pouvant aller de 0.1 (puisqu'on ne peut pas diviser par 0 pour les pixels) à 10 par exemple. Et du coup avoir un retour de la valeur choisie afin de la connaître ?

Phil_1857 · Answer

Bonjour T-Rence,

"J'ai peur que si on zoom que ce ne soit pas toute la carte qui soit zoomée mais juste une zone. Ce qui pourrait du coup fausser les résultats."

Oui, mais tu en es sur ou pas, que seule une soit zoomée ?
Qui décide de ça ?

Déjà, fais un test avec le zoom sur toute la carte pour voir si ca marche, ce sera déjà une première étape

Si seule une zone est zoomée, alors là, pas évident, il faudrait pouvoir savoir quelle zone est zoomée, y  appliquer le coefficient multiplicateur et ajouter le nombres de pixels de la zone non zoomée ...

T-Rence · Answer

Bonjour Phil, 

J'ai pas encore réussi à zoomer l'image. 

Néanmoins j'ai réussi à faire une rotation 

carte = Image.open("Untitled Folder/2_of_spades.png")

carte= carte.rotate(172, expand=1, fillcolor='green')
print (carte.size)
imshow(np.asarray(carte))

J'ai ajouté la couleur verte par sécurité pour les pixels blanc (puisque de base le fond est blanc mais je ne sais pas si c'est comptabilisé dans le calcul.) 

Le problème c'est que les pixels changent en fonction de la rotation. Pour exemple j'ai choisi un AS de pique avec une rotation d'un angle de 172° j'ai donc 56713 pixels noir contre 56404 pixels de base (soit une différence de 309 pixels). 

J'ai donc testé avec le 2 de pique et la même rotation. Là la différence de pixels est de 320. Donc ce qui n'est pas une valeur constante. 

Et si je change la rotation en mettant à 32° par exemple pour le 2 de pique toujours on est à 335 pixels de différence par rapport au code de base. 

Je ne vois pas comment on pourrait régler ça. 

Aurais-tu une idée? 

J'espère avoir été assez clair dans mon explication. 

Merci encore pour ton aide

Phil_1857 · Answer

Bonjour T-Rence,

Effectivement, j'imagine bien que le nombre de pixels puisse changer avec la rotation

Prenons l'exemple simple d'une droite horizontale de 30 mm de long avec des pixels carrés de 5 mm de coté : Il y a 6 pixels

Refais la droite à 45 degrés, toujours sur une grille de pixels de 5 mm de coté et en conservant la longueur de 30 mm: il n'y a plus que 4 pixels

Donc , si on se base sur l'hypothèse que, pour une carte donnée, le nombre de pixels varie proportionnellement avec l'angle de rotation, on peut faire une série de tests de degré en degré et noter le nombre de pixels en fonction de l'angle

Ensuite, quand on teste réellement une carte, on fait comme pour le zoom, en fonction de l'angle, on multiple par un coefficient qui redonne le nombre de pixels originaux

T-Rence · Answer

Je pense comprendre à moitié ce que tu m'expliques. Mais ça me semble assez complexe à réaliser non ? 

Est ce que l'on pourrait pas générer un angle au hasard entre 0 et 360 ? Le stocker dans une variable et du coup gérer les pixels vis-à-vis de cette variable ? 

Par contre ça me semble quasi impossible à réaliser. 

Assez complexe cette partie.

Phil_1857 · Answer

Bonjour T-Rence,

"Mais ça me semble assez complexe à réaliser non ?"

Bah non, tu crée un programme à part, rien que pour compter les pixels, c'est la phase d'acquisition des données, comme quand tu a créé tes quatre listes pixels_trefle, etc ...

Dans ce programme:

Afficher une carte
boucle avec variable a qui varie de 0 à 90
    tourner carte de l'angle a
    compter les pixels noirs ou rouges
    afficher : a   nombre de pixels

Ensuite, vérifier si il y a une proportionnalité entre les angles et le delta nombre des pixels - nombres de pixels carte non tournée

C'est juste pour vérifier l'hypothèse,  si c'est bon, on verra pour la suite

T-Rence · Answer

Bonjour Phil, J'ai essayé de faire le programme que tu m'as dit. Mais j'ai une erreur quand je veux afficher les pixels. carte = Image.open("Untitled Folder/2_of_spades.png") #carte= carte.rotate(32, expand=1, fillcolor='green') print (carte.size) imshow(np.asarray(carte)) Donc ça j'ai pas touché, c'est ce qui permet d'afficher une carte basique. Ensuite j'ai essayé de faire ta boucle: for a in range (0, 90): carte = carte.rotate(a, expand=1, fillcolor='green') #selon moi la carte réalise une rotation de a qui est compris entre et 0 et 90 pixel = carte.load #La variable pixel vis-à-vis de la carte for x in range(0,carte.width): # calcul des pixels sur la hauteur for y in range(0,carte.height): # calcul des pixels sur la largeur print(pixel[x,y])# afficher dans un premier temps tous les pixels J'ai une erreur sur l'affichage qui me dit: "TypeError: 'method' object is not subscriptable" Si je fais un print(a), là j'ai pleins de 0 à la suite donc logiquement 90 si je ne me trompe pas . Et si je fais un print(pixel) ca affiche ce genre de chose: ">" Je ne comprend pas pourquoi le print([x,y]) ne fonctionne pas. Peut etre que la rotation de la carte n'est pas prise en compte mais même lorsque je remplace la variable "a" par une valeur dans la ligne de rotation de la carte, ça me fait le même message.

Phil_1857 · Answer

Pourtant, tu l'as déjà fait dans ton programme ce truc-là:

for x in range(0,carte.width): # calcul des pixels sur la hauteur 
        for y in range(0,carte.height): # calcul des pixels sur la largeur
            print(pixel[x,y])


Et ca marchait, la preuve:

Essaie juste ça, pour voir (pas de boucle de 0 à 90) :

carte = carte.rotate(0.0, expand=1, fillcolor='green')
pixel = carte.load
for x in range(0,carte.width): 
    for y in range(0,carte.height):
        print(pixel[x,y])

T-Rence · Answer

Oui ça marchait mais pas dans cet encart. 

J'ai essayé en enlevant la boucle comme tu m'as dis, mais j'ai la même erreur. 
Je ne vois pas à quoi ça peut être dû. 

Peut être il y a un ordre spécifique à respecter ?

Phil_1857 · Answer

"Oui ça marchait mais pas dans cet encart."

Ca veut dire quoi, ça ?

C'est quoi un encart ???

Tu as bien toujours ton code qui affiche les pixels, non ?

Pourquoi ca ne fonctionnerait plus maintenant ? (sans faire de rotation, par exemple)

T-Rence · Answer

Oui je l'ai toujours et il fonctionne. 

En faite je passe par jupyter. Donc je peux faire étape par étape je sais pas trop si tu vois ce que je veux dire ? 

Et du coup j'ai une étape que pour ça et ça ne fonctionne pas. 

Mais le calcul des pixels sur la carte normal et bien ça fonctionne nickel

Phil_1857 · Answer

Ben justement, dans le code qui calcule sur carte normale, puisque ca marche ici, ajoute à la fin:

carte = carte.rotate(0.0, expand=1, fillcolor='green')
pixel = carte.load
for x in range(0,carte.width): 
    for y in range(0,carte.height):
        print(pixel[x,y])


si il y a bien une carte affichée, ca doit marcher

T-Rence · Answer

En la mettant dans le calcul des pixels, le résultat est identique. C'est  à dire que si je mets cette ligne en commentaire ou non le résultat ne change pas. 

Peut-être que cette ligne de code n'est pas bonne pourtant la rotation fonctionne bien

Phil_1857 · Answer

Donc, si tu applique le code de ma réponse de 13h21,

ca affiche bien les pixels comme sur l'image de ma réponse de 11h24, c'est bien ça ?

T-Rence · Answer

Oui j'ai bien le même affichage. Mais il est identique s'il y a la ligne de code de rotation ou non. Je ne vois pas de différence. 

Est ce qu'est c'est dû au "0.0"?

Phil_1857 · Answer

Ben évidement!

Rotation 0 degrés, la carte reste verticale !

Maintenant, tu essaye avec 20 au lieu de 0 pour voir ....

T-Rence · Answer

Effectivement là le résultat est différent et ça fonctionne. 

Je ne sais pas pourquoi ça ne marchais pas avant. Mon code n'avait pas l'air mauvais. 

Donc à partir de là je n'est pas compris la suite de ton idée

Phil_1857 · Answer

Je proposais donc de faire un bout de code pour analyser la relation angle / perte de pixels

La boucle qui varie de 1 à 91 (puisque le dernier chiffre est exclu de la liste, ca va donc de 1 à 90), non pas pour afficher les pixels, mais pour les compter, comme au début de ce projet

Ca donnerait une liste de ce genre (je mets des valeurs bidon, évidemment) :

angle    nb de pixels    delta par rapport au nb de pixels sans tourner la carte
                                        (on les a déjà dans tes 4 listes par figure)
1           15200               10
2           14850               20
etc ...

Et en examinant la liste complète, on verrait peut-être que l'on perd 10 pixels a chaque degré
comme ici: 1 degré: -10 pixels, 2 degrés: -20 pixels
donc perte = 10 pixels/degré

Et donc en test de reconnaissance réel:

Affichage carte
Rotation 30 degrés (par exemple), donc perte: 30 x 10 = 300 pixels
Comptage des pixels (noirs ou rouges)
Ajout de 300 pixels : on doit retomber sur un nombre de pixels présent dans l'une des 4 listes
du début (pixels_trefle, etc ...)

Fais le déjà pour une seule carte, c'est juste pour vérifier l'hypothèse

T-Rence · Answer

Bonjour Phil, 

J'ai alors pour la carte 10 de pique, ce qui est connu: 114 792 pixels noir

Pour une rotation de 10° j'ai: 115 127 pixels noir soit 335 pixels de différence
Pour une rotation de 20° j'ai: 115 119 pixels noir soit 327 pixels de différence
Pour une rotation de 30° j'ai: 115 101 pixels noir soit 309 pixels de différence
Pour une rotation de 40° j'ai: 115 114 pixels noir soit 322 pixels de différence
Pour une rotation de 50° j'ai: 115 153 pixels noir soit 361 pixels de différence
Pour une rotation de 60° j'ai: 115 100 pixels noir soit 308 pixels de différence 
Pour une rotation de 70° j'ai: 115 115 pixels noir soit 323 pixels de différence 
Pour une rotation de 80° j'ai: 115 126 pixels noir soit 334 pixels de différence
Pour une rotation de 90° j'ai: 114 792 pixels noir soit 0 pixels de différence

J'en conclus pour cette carte qu'il n'y a pas de variable fixe pour le degré de variation et le nombre de pixels de différence. 

J'ai donc testé sur une seconde carte pour voir si pour chaque rotation la différence de pixels est la même pour chaque degré de rotation. 

J'ai pris le 9 de pique, ce qui est connu:  103 151 pixels noir: 

Pour une rotation de 10° j'ai: 103 479 pixels noir soit 328 pixels de différence
Pour une rotation de 20° j'ai: 103 484 pixels noir soit 333 pixels de différence

A partir de là on voit déjà que les valeurs ne sont pas identiques vis-à-vis de la carte précédente.

Phil_1857 · Answer

Bonjour T-Rence,

Effectivement, on ne peut pas en tirer de loi, c'est un peu disparate

Il va falloir trouver autre chose, mais quoi ...

Est-ce que ton prof à la solution, au moins ?
Et les autres, ils font comment ?

T-Rence · Answer

Je pense qu'il doit l'avoir oui. En faite c'est plus "découverte de la recherche" et suite à ça on va devoir écrire un article et le présenter etc. Le soucis c'est que le programme compte dans la "note" et comme je suis pas un dev et que j'ai jamais codé bah je galère un peu. Les autres je ne sais pas vraiment comment ils font vu que tout se fait à distance et que je ne connais personne c'est compliqué. 

Tu penses que le zoom serait plus simple à traiter ? Au pire je sacrifie la rotation pour le zoom.

Phil_1857 · Answer

"comme je suis pas un dev et que j'ai jamais codé ... "

Ok, mais avant de coder en Python (ou autre langage), il faut déjà trouver l'idée sur le papier,
l'algorithme qui permettra de tester une carte

J'ai repris ta liste pixels trèfle[] et j'ai cherché une constante  entre les 10 valeurs
puisque par rapport à l'as, il y a 2 fois plus de figurines 'trèfle' sur le 2, 3fois plus sur le 3, etc ...

Mais ca ne marche pas car sur une carte il n'y a pas les trèfles, il y a aussi le chiffre de la valeur,
avec au dessous la figurine en plus petit, et même, sur l'as, la figurine est parfois différente et décorée



tu peux tester le zoom pour voir si c'est mieux, il y aura peut-être une proportionnalité avec le facteur de zoom

T-Rence · Answer

Je vais essayer de réaliser un zoom sur la photo. Je n'avais pas réussi en début de semaine. Je retente et dès que j'ai les valeurs de zoom je te dis ça

georges97 · Answer

Bonjour T-Rence, bonjour Phil_1857,

J'ai suivi ce fil dans le but de me perfectionner en python. Quand on voit les choses de l'extérieur, plutôt que d'avoir les contraintes "scolaires" de T-rence, on essaie de trouver, par jeu, une solution.

Voila ma proposition, plutôt que de réaliser un tableau ou plutôt une liste qui corresponde à chaque degré d'angle ou à chaque niveau de zoom, pourquoi ne pas générer une liste qui corresponde aux limites de chaque carte.

Je m'explique:

Si par exemple, en rotation les valeurs vont de disons 11000 à 15000 pour l'as et que pour le6 elle vont de 79444 à 82000, il "suffirait" d'établir la liste de base correspondant à un angle de 0°, une seconde liste correspondant à la position extrême de 359° (n vérifiant que cette liste inclue bien les valeurs extrêmes des angles intermédiaires.

Ensuite, en établissant un dictionnaire (fonction python, à l'attention de T-Rence bien sûr)) correspondant à chaque couple valeur inférieure/valeur supérieure, on serait sûr de retourner la bonne carte quelque soit l'angle (ou le zoom) présenté.

@ Phil_1857, il se peut que mon idée soit farfelue ou irréalisable mais considère la comme une simple réflexion par rapport au travail que vous avez tous deux réalisé.

Cordialement

T-Rence · Answer

Bonjour Georges, 

Merci pour ta contribution. 

Si je comprend bien ton raisonnement, il faudrait donc construire une liste par angle qui comprend chaque limite de pixel pour chaque carte ? 

Par exemple pour un angle de 10°: Réaliser par exemple pour l'as  un ensemble style: [11 000 - 11 500] et ainsi de suite pour chaque carte ? 

Ce qui signifie donc réaliser pleins de liste pour chaque angle ? 

Pour ce qui est du zoom je n'arrive vraiment pas à zoomer. 

J'ai alors demandé à mes collègues où ils en sont dans le projet et pour la plupart ils sont dans la même situation. Ils n'arrivent pas à zoomer.

Un collègue vient de me parler de crop pour la partie zoom. Je vais essayer d'approfondir de ce côté là voir ce qui est possible.

georges97 · Answer

Non, justement, pas une liste par angle, juste un couple, constitué des deux extrêmes, la valeur la plus basse et la plus haute, correspondant à l'angle 0° du départ et de l'angle 359°. Mais mon raisonnement est sans doute faux sur la valeur du maximum de pixels, qui pourrait se trouver par exemple pour un angle de 80°.

Ce que tu pourrais faire, c'est relever les valeurs pour 0, 90, 180, 270 et 359°, soit 5 valeurs dont tu retiens le mini et le maxi, que tu utiliseras plus tard dans le dictionnaire (couple mini/maxi) dont je parlais.

Si pour chacune des 10 cartes, ces mini/maxis ne se recoupent pas, en testant l'appartenance du relevé de la carte tirée à un degré de rotation aléatoire, on pourra en déduire si elle entre dans les limites d'un couple puisque tous les couples sont différents.

Tu pourras après compléter en ajoutant l'ensemble des angles au lieu des 5 du premier test.

Par ailleurs, je ne sais pas comment tu relève les valeurs des pixels (c'est le post n°38, n-est-ce pas?), mais une simple boucle doit permettre d'établir la liste constituant le relevé des 360 positions d'angle.

Peut-être veux tu attendre la validation de Phil_1857 avant d'avancer trop loin dans ce qui pourrait ne pas convenir (je pense au dictionnaire), mais je pense que le test sur les 5 valeurs peut être tenté sans trop y consacrer de temps.

A te lire

Phil_1857 · Answer

Hello Georges97,

Pas de problème

Donner une plage de tolérance au lieu de valeurs exactes, ca parait pas mal ...

T-Rence · Answer

Ah oui donc si je comprend bien en gros je prend l'angle ou il y a le minimum de pixels, ainsi que l'angle ou il y a le maximum de pixels ce qui constitue le couple. 

Ainsi si la valeur se situe dans ce couple il s'agit alors de telle carte. 

Mais il faudrait faire ça pour tous les angles puisque comme vu dans l'exemple ou je cite les différences de pixels. Cela varie en fonction de chaque angle et n'est pas proportionnel (dans le sens où un angle de 10° peut avoir plus de pixels qu'un angle de 30° mais moins que celui de 20°). 

Je sais pas si vous voyez ce que je veux dire ? 

En tout cas s'il faut faire ça, je le ferais surement demain parce que je vous avouerais que je me suis donné la migraine. 

Merci encore pour votre aide en tout cas

georges97 · Answer

je prend l'angle ou il y a le minimum de pixels, ainsi que l'angle ou il y a le maximum de pixels oui, et tu les notes pour vérifier quand tu l'auras fait pour les 10 cartes qu'il n'y a pas de recoupement (il ne devrait pas y en avoir puisque la somme de pixels à l'air différente d'une carte à l'autre)


il faudrait faire ça pour tous les angles puisque comme vu dans l'exemple ou je cite les différences de pixels.

Ne le fais pas pour le moment. Fais le pour 4 ou 5 valeurs d'angles, come je le décrivais. Le calcul des 360 angles se fera dans un second temps par une boucle (de 0 à 359)

On ne s'occupe pas de vérifier la proportionnalité? Seule l'intervalle sera pris en compte.

Je tente une illustration:

as

mini=10000
maxi-12000

2

mini=25000
maxi=28000

3

mini=28000
maxi=32000

etc.


Mon "système" ne peut fonctionner que si les valeurs de ces couples ne se recoupent jamais, sinon, il y a "bataille" entre deux cartes.

On a donc 10 couples de valeurs, qui serviront à créer un dictionnaire, sorte de liste constituée de couple de deux éléments liés l'un à l'autre. On parle d'immutabilité en python, c'est à dire sur l'on ne peut pas changer les valeurs.

Ca donnera quelque chose comme cela (je suis quasiment en mode algorithmique là, je n'ai pas vérifié la syntaxe.

Je crée donc un dictionnaire mini_maxi pour les 10 cartes

dico_minmax={"mini1": 10000, "maxi1": 12000,"mini2": 25000, "maxi2": 28000,"mini3": 28000, "maxi3": 32000,....}

Chaque couple dans le dictionnaire ext un indice de 0 à 9 donc.

Une fonction if sera utilisée our comparer la carte entée, quelque soit son orientation, puisqu'elle devrait se situer dans l'intervalle d'un des 10 couples.

Par exemple, si la valeur de la carte entrée est de 26000 pour un angle de 30°, c'est le 2, si c'est 27500, c"est aussi le 2.

Si c'est 310000, c'est le 3.

En fait, on ne se préoccupe plus de l'angle, qui a été traité en amont, ou plus exactement contourné puisqu'on a enregistré dans une liste les 360 valeurs que peut prendre une carte et qu'on n'en a extrait le min et le maxi grâce aux fonctions min() et max()

La dernière partie consistera à tester par un if à quel couple correspond la a valeur-pixels de la carte entrée. Pour cela , on teste tour à tour chaque couple du dictionnaire jusqu'à atteindre l'intervalle correspondant à la valeur recherchée.


A l'attention de Phil, si cela n'est pas possible par le dictionnaire, c'est sans doute envisageable sur une liste et peut-être plus simple puisqu'il suffira de s'arrêter quand on atteindra la valeur recherchée:

ma_liste_valeurs(10000,12000;25000,28000,32000) et le if ressemblera à quelque chose comme:
for carte_entrée in range ma_liste_valeurs:
    if carte_entrée<indice_liste:
        carte_sortie=valeur(indice_liste) soit la carte 3 pour l'indice 2

Je suis à la retraite et dispose de temps mais le concours de Phil sera indispensable pour la dernière partie car je ne suis qu'un junior en python (mais pas en âge) et si ma piste est correcte, il aura sans doute des idées d'amélioration.

A bientôt.

georges97 · Answer

Au fait Phil, nous n'avons pas de nouvelles de Phil et surtout de son programme.

"Mort aux pluches" comme on disait de notre temps ou passé à C pluche pluche et nous ayant laissé avec son ex-problème?

T-Rence · Answer

Bonjour à tous, 

Désolé pour le délai de réponse, j'ai eu quelques soucis perso qui fait que j'ai baissé pas mal les bras.

Je tiens à m'excuser auprès des personnes qui ont pris du temps pour me répondre et pour m'aider. 

Je vous remercie grandement de l'aide que vous avez pu m'apporter. J'ai un peu evolué grâce à vous meme si mon niveau en code reste presque null. 

Pour info j'ai toujours pas la solution de ce problème, mais le prof m'avait parlé qu'avec un réseau de neuronnes c'était totalement faisable mais il l'a dit lui même que pour nous c'était quasi impossible. Il a surtout souligné les démarches de recherches qui ont été effectué par chacun. 

Je sais pas si vous vous y connaissez en réseau de neuronnes mais sachez qu'avec ce genre de système cela est faisable. 

Si jamais vous avez des questions sur le sujet je pourrais faire l'intermédiaire pour y répondre. 

Encore une fois, merci à vous pour votre aide.

Phil_1857 · Answer

Bonjour t-rence,

Les réseaux de neurones, je connais, j'ai déjà fait un programme qui, après une phase 

d'apprentissage, reconnait ou bien des lettres, ou bien des chiffres sur une grille de 5x5 pixels ...

georges97 · Answer

Bonjour T-rence,

Merci pour ce retour. J'imaginais bien que vous aviez du mal à compléter ce programme, qui n'est effectivement pas d'un niveau débutant.

Je connaissais le principe du réseau de neurones, qui sert entre autres choses dans le domaine de l'Intelligence Artificielle, dont notamment l'identification d'un individu dans une foule ou la détection des comportements déviants (les chinois sont très avancés dans ces spécialités) entre autres choses nécessitant un apprentissage par mix algorithmes-analyse de données.

Pour ma part, j'ai parmi mes nombreux projets, celui d'une ruche connectée où la reconnaissance de formes serait utilisée pour le comptage des abeilles et la détection de leurs migrations hors de la ruche (carte raspberry pi). Je n'ai pas le niveau pour écrire ce genre de programme in extenso mais plusieurs existent déjà, qui utilisent des bibliothèques de python (il me semble qu'il y en a une chez Google).

Je constate que votre professeur a apprécié vos efforts pour résoudre l'exercice, ce qui vous aura fait progresser, ce qui est le but de toute pédagogie. Comme le disait Coubertin, "l'important...")

Je vous souhaite bonne continuation dans vos études et le reste.

Georges

Phil_1857 · Answer

Bonjour t-rence,

Je pense que tu peux marquer cet appel comme résolu ........

Analyse d'une image

49 réponses

Discussions similaires