Bonjour,

Je suis en 2eme année de CPGE et j'ai pour mon concours un TIPE à réaliser. Voila, je voudrais mettre en place la goalline technology pour le rugby. Ce qui permettrait de faciliter le travail des arbitres pour valider les drops et les pénalités. Mais voilà, pour ceci, j'ai besoin de calculer a chaque fois la trajectoire du ballon en prenant le point le plus bas mais malheureusement c'est une notion d'informatique qui m'échappe. J'aimeri savoir s'il y aurai la possibilité que quelqu'un m'explique comment faire faire svp.

Bonjour,

FlorentChassaing a écrit:

Mais voilà, pour ceci, j'ai besoin de calculer a chaque fois la trajectoire du ballon en prenant le point le plus bas mais malheureusement c'est une notion d'informatique qui m'échappe. 

Peux-tu préciser ce que tu veux exactement? c'est quoi le point le plus bas dont tu parles ?

Dans ton cas voila comment je modeliserais le ballon par:

- 2 points espacé de la longueur du ballon

- 1 Ellipse de révolution passant par ces 2 points avec des foyers et un petit coté à déterminer.

Ensuite il devrait être "assez" simple géométriquement de connaitre l'ensemble des points de la courbe mais par contre je ne sais pas comment tu veux modéliser la trajectoire des 2 points. Il y a trop de paramètres. Je pense qu'en réalité c'est géré par des algo de ML (notamment des Convolutionnal Neural Network) qui permet de "voir" la position du ballon ou alors une reconstruction par photogrammétrie.

Je ne suis pas expert dans ce domaine mais physiquement tu vas avoir du mal a géré la dynamique du ballon

Tout d'abord merci de m'avoir donner des conseils. Pour le point le plus bas je pense que c'est celui du ballon qui est le plus proche de la Terre à chaque fois. Mais j'ai décidé de prendre le centre du ballon, me disant que c'est surement plus facile et que ceci enlève un problème. J'ai pensé un modéliser le problème comme le problème du boulet de canon en Physique. Après je veux faire particulièrement du traitement d'image et donc je voulais savoir comment calculer la trajectoire d'un point grâce au image.

Bonjour,

Si ta caméra est fixe, tu peux surement arriver a retourner la position du ballon sur l'image avec un Convolutionnal Neural Network. Si tu passes chaque image dans ce reseaux, tu peux surement avoir le x/y à chaque 1/60eme de secondes (si tu as 60img/s ^^)

Comment recuperer le x,y ca par contre je ne sais pas exactement

Ensuite, si tu arrives a recuperer sur l'image la taille du ballon, tu peux surement estimé la distance et en ayant la position de la caméra avoir donc sa position dans l'espace. Sinon il te faut 2 caméra et positionner ton ballon avec les 2 images obtenues (je crois que c'est de la trilatération mais je ne suis pas sur)

En tout cas bon courage car ca ne se fera pas en 2min. Il faut deja faire le CNN, ensuite le trained avec des images de ballons de rugby, arriver a recuperer la position et ensuite faire des maths ! En tout cas c'est faisable

Bonjour,

Merci de l'aide . J'ai encore quelques questions ayant fait des recherche sur le CNN. Il fonctionne en deux étapes. Est ce du traitement d'image et donc cela permet de savoir la position de la balle ou cela modifie juste l'image? Il en existe déjà sur python ou il faut le créer de toute pièce ?

-
Edité par FlorentChassaing 3 octobre 2017 à 13:32:21

Je doute que ça existe pour te donner la position du ballon directement. Il faudra que tu l’entraînes avec des photos avec et sans ballon par exemple.

Pour le coder ne t'embête pas à le faire a la main, tu as des libs pour créer et entraîner des réseaux de Neurones (TensorFlow, Caffe, Theano, Keras sont les plus connus) - avec en tête TensorFlow (fait par Google )

Pour la position, je ne sais pas trop encore le faire mais en gros ton algo devrait te fournir en sortir un résultat comme la video sur ce lien

https://pjreddie.com/darknet/yolo/

Avec le ballon uniquement donc le modèle sera plus simple... ouf

En fonction de la taille de la zone de détection sur les 2 caméras, tu devrais être en mesure par trigonométrie de connaitre sa position.

Une chose est presque sur, tu ne devrais pas utiliser de MaxPoolingLayer pour ne pas perdre l’information de position.

Cette vidéo te sera aussi très utile si tu parles anglais :) https://youtu.be/n0jM1cvmyEs?t=38m24s

(Je te l'ai calé a l'endroit ou il montre le résultat sur la détection uniquement d'un panneau STOP)

EDIT 1 : Tu peux aussi t'inspirer de cette video https://www.youtube.com/watch?v=cAICT4Al5Ow

EDIT 2 : Il existe des site qui propose des images déjà classées comme par exemple imagenet... tu peux peut être trouver ton bonheur dessus pour train ton NN (attention plus ton NN sera profond, plus le training sera lent)

-
Edité par coni63 3 octobre 2017 à 16:26:43

Bonsoir, je reviens vers vous car voila j'ai décidé de faire comme si on avait déjà les photo dans l'ordi(manque de temps ^^) et donc de faire un simple traitement d'image qui consiste à savoir s'il y a un pixel blanc (couleur du ballon ) par exemple au milieu des deux poteaux pour valider la pénalité. Voici mon début de code:

import os

import numpy as np

import matplotlib.pyplot as plt

import matplotlib.cm as cm

os.chdir("D:/")

im=plt.imread("penalite.png")

n,p,c=np.shape(im)

#plt.imshow(im,cmap=cm.gray)

def noiretblanc(image):

imnb=np.zeros((n,p))

for k in range(n):

for i in range (p):

imnb[k][i]=(image[k][i][0]+image[k][i][1]+image[k][i][2])

return imnb

a,b=np.shape(imnb)

def fond(image):

imf=np.zeros((a,b))

for k in range(a):

for i in range(b):

if(im[k][i]!=0):

imf[k][i]=0

return imf

imnb=noiretblanc(im)

imf=fond(imnb)

plt.imshow(imf,cmap=cm.gray)

j'aimerai savoir comment je peut créer une fonction pour flouter le derrière de l'image car on suppose qu'il y aura les tribune ^^. voici l'image sur la quel je fait mes essaie pour l'instant 

Merci d'avance pour l'aide

Salut

Si tu trouve un algo qui fait ca tu peux gagner pas mal d'argent (il y a eu sous peu une compétition sur Kaggle à ce propos).

Tu pourras difficilement flouter simplement un fond car celui ci varie (ca peut etre un ciel bleu, nuageux, des tribunes, etc...). Dans ton cas, si ta caméra est fixe, tu peux sauvegarder l'ensemble des position des poteaux et ensuite garder que cette partie de la matrice mais ton ballon aussi bougera et la je ne sais pas comment tu peux faire (c'est pour cela que les CNN dépassent les algo classiques car ils apprennent à détecter les features importantes plutot que les features useless).

NB : la prochaine fois ense a mettre ton code dans les balises car a lire c'est pas top.

Salut,

Tout d'abord merci ! Pour commencer, j'ai vu avec un de mes prof de prendre une photo de départ ou le ciel est bleu et donc de relever que les pixels blanc de la photo que voici:

Pour cela, j'ai donc décidé de prendre le tableau de valeurs des pixels avec le code suivant, est-il bon svp ?

def tableaudepixel(image):
    im=np.zero((n,p))
    for k in range (n):
        for i in range (p):
            c=[]
            im[k][i][0]=image[k][i][0]*1000/4
            im[k][i][1]=image[k][i][1]*1000/4
            im[k][i][2]=image[k][i][2]*1000/4
            c=c+im[k][i][0]+im[k][i][1]+im[k][i][2]
    return (c)

Bonjour,

Pourquoi dupliquer l'information, tu as ton images et tu refais un tableau (im et c) 2 tableaux ?  D'ailleurs sur c, tu additionne tout sur 1 seul élément, est-ce voulu ? Je ne comprends aussi pas trop ton *1000/4. Généralement on divise par 255 pour tout scale dans l'unité (ca accélère les calculs sur les réseaux de neurones). Dans ton cas, ta fonction devrait être simplifiable a :

image = np.sum(image, axis=2)*250

Ensuite si tu recherche les pixel proche du blanc a toi de trouver un seuil et de faire 

face = np.sum(face, axis=2)/(255*3)
image = np.where(face > 0.9, 1, 0)

# test
print(np.sum(image)) => 156

Mon image a donc 156 pixels proche du blanc et le rendu me donne :

Alors que limage de base est :

bonjour, j'ai travaillé en négatif et j'essaye de mettre l'image dans une fenêtre pour pouvoir intervenir dessus avec des ligne et des point et je voulais donc savoir si c'est possible et comment on fait. Voici mon code pour l'instant:

import os
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from pyg import *

os.chdir("D:/")
im=plt.imread("en-but.png")
im2=plt.imread("en-but avec ballon.png")
n,p,c=np.shape(im)
a,b,d=np.shape(im2)
#plt.imshow(im,cmap=cm.gray)

def noiretblanc(image):
    imnb=np.zeros((n,p))
    for k in range(n):
        for i in range (p):
            imnb[k][i]=(image[k][i][0]+image[k][i][1]+image[k][i][2])
    return imnb


def negatif (image):
    n,p=np.shape(image)
    imneg=np.zeros_like(image)
    for k in range(n):
        for j in range(p):
            imneg[k][j]=1-image[k][j]
    return(imneg)
    

imnb=noiretblanc(im)
imf=negatif(imnb)

def affichage(image):
    fenetre(400,400,"penalitée")
    remplir_ecran(image)

affichage(imf)

bonjour je relance le sujet car j’aimerai afficher mes deux images modifier cote à cote et je voulais savoir comment faire. Je vous transmet le début de mon code:

import os
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from pyg import *
from tkinter import*


os.chdir("D:/")
im=plt.imread("poteaux.png")
imbis=plt.imread("en-but.png")
im2=plt.imread("en-but avec ballon.png")
n,p,c=np.shape(im)



def noiretblanc(image):
    imnb=np.zeros((n,p))
    for k in range(n):
        for i in range (p):
            imnb[k][i]=(image[k][i][0]+image[k][i][1]+image[k][i][2])
    return imnb


def negatif (image):
    n,p=np.shape(image)
    imneg=np.zeros_like(image)
    for k in range(n):
        for j in range(p):
            imneg[k][j]=1-image[k][j]
    return(imneg)
    
def cam(image):
    imagenb=noiretblanc(image)
    imagetraité=negatif(imagenb)
    return(imagetraité)

def affichage():
    afficher=plt.imshow(cam(im),cmap=cm.gray)
    return afficher
    
affichage()

serait ils possible de les afficher cote a cote pour pouvoir les traiter en meme temps ou alors l'une apres lautre