compter le nbre de personne sur une image

**deb_Sous_Python** · 18/04/2007, 15h11

salut

Tout d'abord je suis nouveau sur ce site... alors bonjour a tous

je veux créer un algo sous python qui compte le nombre de personne qui'il y a sur une image.
je voudrais éliminer les ombres d'une image afin de ne pas les confondre avec les personnes.

je dispose d'une image avec plusieurs personnes (vue de dessus) et de la même image sans les personnes(fond)

est ce quelqu'un pourrais me donner un coup de main pour réaliser cette algo.

vous trouverez en pièce jointe ce que j'ai déjà réaliser.
et voila par quoi j'ai commencer:

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
import Image
import numpy
import ImageOps
import PIL
import ImageChops
 
 
def OuvrirImg(fichier2):
	fichier = Image.open("c:\\a.jpg")		
	fichier = ImageOps.grayscale(fichier)		
	fichier1 = Image.open("c:\\c.jpg")
	fichier1 = ImageOps.grayscale(fichier1)
	scale=2
	offset=128
	fichier2 = ImageChops.subtract(fichier,fichier1,scale,offset)
	fichier2.show()
	histo=numpy.histogram(fichier2)
	#print histo
	largeur,hauteur = fichier2.size			
 
	fichier2data = fichier2.getdata()		
	tab=numpy.array(fichier2data)			
	#print numpy.shape(tab) 
	matrix = numpy.reshape(tab,(largeur,hauteur))  	
	return matrix
 
 
 
Img=OuvrirImg("c:\\a.jpg")
 
print Img
mat = numpy.multiply((Img>210),numpy.ones(Img.shape))	
print mat
 
mat=mat*255
print mat
 
 
 
seuillage=Image.new("L",(mat.shape[0],mat.shape[1]))
seuillage.putdata(list(mat.flat))
seuillage.show()
 
 
######################################################

**poukill** · 18/04/2007, 15h33

classique comme problème, mais très compliqué si tu veux faire ça bien...
Deux personnes trop proches vont donné un groupe

Il faut que tu trouves un critère discriminant pour déterminer si oui ou non il y a quelqu'un sur l'image!

En vrac:
1) Tu fais la différence entre ton image et l'image de référence
2) seuillage + autres prétraitements. Un bon seuillage va te virer les ombres
3) Morphologie mathématique : érosion pour bien distinguer des formes connexes (éviter de sur compter)... Fermeture éventuelle pour rassembler ensuite (à voir)
4) Labellisation des régions connexes
5) Tu comptes ton nombres de régions

Voilà! Facile !

Bonne chance, et bienvenue sur developpez.com

**parp1** · 18/04/2007, 15h50

Envoyé par poukill

3) Morphologie mathématique : érosion pour bien distinguer des formes connexes (éviter de sur compter)... Fermeture éventuelle pour rassembler ensuite (à voir)
4) Labellisation des régions connexes

Oula pour faire les choses bien je pense qu'il faudrait implémenter le SKIZ ou Squelette par region d'influence.

En effet si des personne marche 'collé' 'Ouais bon on ne sais jamais quant on est rond comme une queue de pelle... ca peut arriver... ou quant on est amoureux.'

Une fois le Skiz fait tu l'inverse tu le seuil afin d'extraire une sorte de Ligne de partage des eaux.

Tu peux faire cela grace a la LPE avec contrainte..

tu fait la soustraction de tes silouette moins le seuille de ton skiz inversé et normalement tu peux compte tu n'auras pas de double comptage.

Va voir du coté de Cassage d'amas... ou chose comme ca.

Je sais que c'est une technique que j'ai apprise et qui fonctionne bien.

Peut etre une autre piste ... la recherche des cranes. On marche rarement la tete collé... encore une fois a moins de s'etre pris un caillasse sévere...

Piste a developper.. Bienvenu! Pour le python Pure va ici Ya aussi plein de tutos dont un d'initiation a Numpy mais je vois que tu a l'aire de maitriser.

La dilatation et l'érosion y sont implémenté.

Va voir ici : Ou clic sur le lien dans ma signature.

**ol9245** · 18/04/2007, 15h53

La méthode e poukill est "simple et de bon gout".

Pour aller plus loin tu peux compter les têtes : plus sélectif, moins d'erreur.

1/ chercher les éllipses (ya des algos tous faits pour ça sur Internet).
2/ Tes têtes vues de dessus sont des éllipses avec certaines caractéristiques de couleur (que tu peux filter en HSV) et de taille (vu la position de ta caméra, toutes tes têtes ont la même taille sur ton image
Compter les têtes te permet donc d'être très sélectif.

Autre méthode, toujours avec les recherche d'élipses : compter les orteils et diviser par dix.

OL

**parp1** · 18/04/2007, 16h31

Envoyé par ol9245

2/ Tes têtes vues de dessus sont des éllipses avec certaines caractéristiques de couleur (que tu peux filter en HSV) et de taille (vu la position de ta caméra, toutes tes têtes ont la même taille sur ton image

Euh pour les personnes brune on pourrait les eliminer avec l'ombre...donc pour les caracteristique de couleurs... en plus il n'y a pas que les bruns....

Pour la taille... c'est a peu pres la meme paire de manche, si c'est un nain ou un enfant, meme dans les bras de son pere sa tete sera plus petite. Pour le nain peut etre que la perspective pourrait y jouer mais pas sur.

Mais comme je l'ai dit c'est une piste a explorer.

**deb_Sous_Python** · 18/04/2007, 16h54

merci pour cette aide parce que j'en ai grave besoin.....

comme je vous l'ai dit je suis pas très doué en info, surtout avec python mais je suis obligé de le faire ici!!!!

le pb c'est que le seuillage ne réduit pas les ombres!!!
comment faire une érosion sous python?
Labelisation des regions c'est quoi?
et comment compter les régions?

filtre HSV c'est quoi?

parp1 c'est super intéressant mais je comprend pas la moitié désolé

ou est ce que je peux trouver les algo pour ellispe sous python?

merci encore parce que sans vous mon projet est mort

**parp1** · 18/04/2007, 17h12

Envoyé par deb_Sous_Python

comment faire une érosion sous python?

Labelisation des regions c'est quoi?

et comment compter les régions?

filtre HSV c'est quoi?

Pour l'érosion clic sur le lien que j'ai dans ma signature j'ai fait un tutoriel en python pour l'initiation a numpy... et ca tombe bien pour toi il y a erosion et dilatation.

La labelisation des regions consiste (si je ne m'abuse) a dire au programme qu'un amas de pixels sera un objetX, un autre amas sera un objet Y et ainsi de suite.

Le filtre HSV... c'est un autre codage que Rouge Vert Bleu.

Hue Saturation Value C'est un autre espace de couleurs. Il y en a plein, CMJ,CielAB CielUV je m'arrete la.

Pour savoir ce qu'est HSV ouvre Paint va dans editer tes couleurs.

Tu a le choix entre : entre trois valeur RGB ou trois valeurs HSV. par exemple pour faire varier la luminescance tu bouge le scroll bar verticale.
Pour la teinte tu deplace de facon horizontale dans le carré
Pour la saturation de facon verticale.

Si tu veux plus d'info va sur easyRGB.com

Surtout n'esite pas avec les questions.

Dernier chose peut tu nous mettre les images resultats que ton script te rends. Merci!

**poukill** · 18/04/2007, 19h12

parp1, je pense personnellement qu'une bonne méthode n'est pas forcément la plus compliqué...
Va t'en lui expliquer que le skelette d'un ensemble connexe est l'ensemble des centre des boules maximales...

La détection de personne a déjà été traité par plein de labo de traitement d'images, notamment l'INRIA à Sophia Antipolis (projet ORION).

Je ne connais pas les contraintes de temps de notre ami, mais la solution que je propose a l'avantage d'être simple, et la morpho math a déjà fait ses preuves, largement. Si ça marche pas, on peut faire plus compliqué... comme tu l'as fait remarqué.

Mais est-ce bien nécessaire???

**ol9245** · 19/04/2007, 05h21

Envoyé par parp1

Euh pour les personnes brune on pourrait les eliminer avec l'ombre...donc pour les caracteristique de couleurs... en plus il n'y a pas que les bruns....

Pour la taille... c'est a peu pres la meme paire de manche, si c'est un nain ou un enfant, meme dans les bras de son pere sa tete sera plus petite. Pour le nain peut etre que la perspective pourrait y jouer mais pas sur.

Mais comme je l'ai dit c'est une piste a explorer.

J'avais vu ça sur un article que j'ai perdu : recherche d'éllipses, ouis tri selon le contenu HSV de l'éllipse et évidemment sa taille. Ca avait l'air magnifiquement robuste. ici c'est encore plus simple car les t^tes sont vues de dessus. Justement, pour les têtes, c'est une des parties du corps qui est la plus normée. Les différences de taille sont donc négligeeables. Et comme cette caméra est au-dessus d'une porte, l'effet de perspective du à la taille de la personne est borné. Donc le modèle ellipse des têtes peut être borné par des données physiques (position de la caméra) et physiologique (taille et age des personnes qu'on souhaite identifier/perdre). Franchement, avec un modèle aussi robuste à portée, j'hésiterais pas beaucoup.
Pour les ombres, elles vont être analogues aux cheveux en luminance, mais ni en couleur ni en saturation.

Et en écrivant, il est clairement trivial de détecter les ombres car on connait la scène sans personages. L'ombrage fit changer la luminance, mais pas la saturation ni la couleur. Donc le personage lui-même, c'est ce qui fait changer le vecteur saturation/couleur.

C'est la force du HSV de pouvoir mettre de côté la luminance qui est imprévisible et donc inexploitable, et de réduire l'information à deux canaux utiles : couleur et saturation.

Autre piste : ls persones en général ne se touchent pas. au moin dans un environnement professionnel. donc pas forcément besoin e chercher les têtes.

Mon algo de première intention (dsl je connais pas python. c'est du matlab. j'espère compréhensible avec les commentaires :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
base = rgb2hsv (image_de_base) ; % passage en HSV (valeurs H, S et V dans [0 1])
base = base (:,:,1:2) ; % suppression de la luminance (le V)
 
image = rgb2hsv (image_avec_personages) ; 
image = image (:,:,1:2) ; % suppression de la luminance
 
delta = image - base ; différence entre les deux images dans le plan HS. 
variation = sum(delta .^2, 3) ; % norme au carré de la différence
 
imshow(variation) ; affiche l'image pour vérifier qu'on a plus les ombres ni le fond.
 
seuil = 0.2*0.2 ; % si un pixel a changé de20% en H ou S, je le garde
variation_bin = (variation > seuil) ; % seuillage

Il reste la labellisation. (donc encore un peu de travail pour toi

ensuite tu regarde la taille de tes paquets en pixels. ça doit pas poser de pb de discerner les gros paquets des petits.

OL

**deb_Sous_Python** · 19/04/2007, 08h49

voici pour l'instant mes résultats:

les tetes ne sont pas des ellipses pleines... en plus le corps et les ombres sont toujours présents.

qu'est ce que vous en pensé?

**deb_Sous_Python** · 19/04/2007, 09h01

savez vous quel code python je dois réaliser pour filtrer en HSV?

si je filtre en HSV je ne dois pas seuiller? je reste en couleur c'est ca?

**poukill** · 19/04/2007, 09h22

Merde j'avais pas vu que la vue était par le dessus, ça change tout

C'est pas mal... A mon avis tu peux faire mieux encore au niveaux des prétraitements... Je suis étonné que tu vois encore le sol après la différence entre les deux images. Ton seuillage doit être mauvais.

Après:
1) Fais de la morpho mathématique pour fermer tes surfaces.. (fermeture)
2) Intercorrélation avec une forme de tête classique (prend une ellipse dessinée toi même)
3) Tu comptes dans ton image le nombre de pic d'intercorrélation que tu as (en gros: seuillage + extraction de surfaces connexes)
J'avais fait un projet dans mon école ou je devais compter le nombre d'anneau dans une chaîne industrielle.

Voilà, c'est sûr que çà marche.

**deb_Sous_Python** · 19/04/2007, 09h41

j'ai réalisé l'érosion mais ce ne marche pas lol!!!

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
import Image
import numpy
import ImageOps
import PIL
import ImageChops
 
 
def OuvrirImg(fichier2):
	fichier = Image.open("c:\\a.jpg")		
	fichier = ImageOps.grayscale(fichier)		
	fichier1 = Image.open("c:\\c.jpg")
	fichier1 = ImageOps.grayscale(fichier1)
	scale=2
	offset=128
	fichier2 = ImageChops.subtract(fichier,fichier1,scale,offset)
	#fichier2.show()
	fichier2.save("c:\\fichier2.jpg")
	histo=numpy.histogram(fichier2)
	#print histo
	largeur,hauteur = fichier2.size			
 
	fichier2data = fichier2.getdata()		
	tab=numpy.array(fichier2data)			
	#print numpy.shape(tab) 
	matrix = numpy.reshape(tab,(largeur,hauteur))  	
	return matrix
 
def RebuildImg (Erode):
	Copie = Image.new("L",(Erode.shape[1],Erode.shape[0]))
	Copie.putdata(list(Erode.flat))
	Copie.save(fp="C:\\Erosion.jpg")
	Erosion=Image.open("C:\\Erosion.jpg")
	Erosion.show()
 
################################################################## Ouverture de fichier
Img=OuvrirImg("c:\\a.jpg")
 
#print Img
mat = numpy.multiply((Img>210),numpy.ones(Img.shape))
#print mat
 
mat=mat*255
#print mat
 
################################################################## Seuillage	
 
seuillage=Image.new("L",(mat.shape[0],mat.shape[1]))
seuillage.putdata(list(mat.flat))
#seuillage.show()
seuillage.save("c:\\seuillage1.jpg")
 
################################################################## Erosion
 
Erode=[0]*(seuillage.shape[1]-2)*(seuillage.shape[0]-2)
h=0
for i in range(1,seuillage.shape[0]-1):
	for j in range(1,seuillage.shape[1]-1):
		Erode[h]=min([seuillage[i-1][j-1],seuillage[i][j-1],seuillage[i+1][j-1],seuillage[i-1][j],seuillage[i][j],seuillage[i+1][j],seuillage[i-1][j+1],seuillage[i][j+1],seuillage[i+1][j+1]])
		h+=1
Erode=numpy.array(Erode)
Erode=numpy.reshape(Erode,(seuillage.shape[0]-2,seuillage[1]-2))
RebuildImg(Erode,"c:\\Erosion.jpg")

**ol9245** · 19/04/2007, 10h05

Envoyé par deb_Sous_Python

savez vous quel code python je dois réaliser pour filtrer en HSV?

si je filtre en HSV je ne dois pas seuiller? je reste en couleur c'est ca?

dans le petit code matlab que je t'ai proposé tu peux voir (cf commentaires que j'ai mis car je sais que tu n'est pas sur matlab) que je te propose de passer tes images e HSV, de faire la différence entre les deux, de virer le canal V (luminance) et de faire la somme du carré des différences des deux autres canaux (H et S). A mon avis, ce traitement te donnera une image facile à seuiller et tu te débarrassera facilement des ombres CAR LES OMBRES NE CHANGENT PAS LE CANAL H NI LE CANAL S.

OL

**deb_Sous_Python** · 19/04/2007, 10h15

ok je vais essayer de faire comme ca... merci OL

quelqu'un connais le code sous python pour transformer une image en HSV?

merci d'avance

**poukill** · 19/04/2007, 11h26

dans ton code, je ne vois pas:
*de paramètre pour le seuillage
*de paramètre pour l'érosion

C'est la BASE...

**deb_Sous_Python** · 19/04/2007, 11h39

ouias je suis novice en info en plus je suis forcé de le faire sous python que je ne connais pas alors tu vois la merde.....

j'ai essayé l'érosion mais mon code ne fonctionne pas;

et le seuillage marche comme même.

mais j'aimerais bien passé en HSV pour voir ce que ca donne?

**deb_Sous_Python** · 19/04/2007, 11h59

j'ai une erreur a la fin pour l'érosion

mon code est bon?

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
import Image
import numpy
import ImageOps
import PIL
import ImageChops
 
 
def OuvrirImg(fichier2):
	fichier = Image.open("c:\\a.jpg")		
	fichier = ImageOps.grayscale(fichier)		
	fichier1 = Image.open("c:\\c.jpg")
	fichier1 = ImageOps.grayscale(fichier1)
	scale=2
	offset=128
	fichier2 = ImageChops.subtract(fichier,fichier1,scale,offset)
	#fichier2.show()
	fichier2.save("c:\\fichier2.jpg")
	histo=numpy.histogram(fichier2)
	#print histo
	largeur,hauteur = fichier2.size			
 
	fichier2data = fichier2.getdata()		
	tab=numpy.array(fichier2data)			
	#print numpy.shape(tab) 
	matrix = numpy.reshape(tab,(largeur,hauteur))  	
	return matrix
 
def Erosion (seuillage):
	Erode=[0]*(seuillage.shape[1]-2)*(seuillage.shape[0]-2)
	h=0
	for i in range (1,seuillage.shape[0]-1):
		for j in range (1,seuillage.shpae[1]-1):
			Erode[h]=min([seuillage[i-1][j-1],seuillage[i][j-1],seuillage[i+1][j-1],seuillage[i-1][j],seuillage[i][j],seuillage[i+1][j],seuillage[i-1][j+1],seuillage[i][j+1],seuillage[i+1][j+1]])
			h+=1
	Erode=Numpy.array(Erode)
	Erode= numpy.reshape(Erode,(seuillage.shape[0]-2,seuillage.shape[1]-2))
	Erode.show()
 
 
################################################################## Ouverture de fichier
Img=OuvrirImg("c:\\a.jpg")
 
#print Img
mat = numpy.multiply((Img>210),numpy.ones(Img.shape))
#print mat
 
mat=mat*255
#print mat
 
################################################################## Seuillage	
 
seuillage=Image.new("L",(mat.shape[0],mat.shape[1]))
seuillage.putdata(list(mat.flat))
#seuillage.show()
seuillage.save("c:\\seuillage.jpg")
 
################################################################## Erosion
 
E= Erosion(seuillage)

**poukill** · 19/04/2007, 12h41

Envoyé par deb_Sous_Python

ouias je suis novice en info en plus je suis forcé de le faire sous python que je ne connais pas alors tu vois la merde.....

j'ai essayé l'érosion mais mon code ne fonctionne pas;

et le seuillage marche comme même.

mais j'aimerais bien passé en HSV pour voir ce que ca donne?

L'érosion en tant que telle est un concept de traitement d'image. Tu dois spécifier la taille et la forme de l'élément structurant etc...

est ton ami aussi : tu aurais trouvé http://www.ext.upmc.fr/urfist/image_...hapitre3_1.htm
si tu avais cherché un peu...

Le seuillage c'est pareil, il faut un SEUIL:qu'as-tu choisi? 128?64?39?247?
Bref, il te faut essayer plusieurs valeurs pour trouver le seuil optimal.

Chaque traitement de ta chaîne doit être optimisé pour que la chaîne totale soit optimale et fonctionne bien.

Qui te force à faire ça sous Python? il doit y avoir une raison, non?
C'est que dans ton planning tu devrais avoir:
*un peu de temps pour réfléchir en expérimenter des choses en traitement d'image (avec matlab par exemple)
*un peu de temps aussi pour te former sous Python (que je ne connais pas) et implémenter tout ce que tu as vu sous Matlab...

Un projet, ça se gère...

Bon courage,

**parp1** · 20/04/2007, 11h52

Je me suis embeter a faire un tutoriel sur une initiation au traitement d'image avec numpy et python... On y traite de la manipulation de bases des images (comment les lire, les traiter) On y traite aussi le seuillage l'érosion et la dilatation.

Donc prends la peine de lire ce tutoriel, recherche aussi un peu des cours de base en traitement d'image.

Autre chose lorsque tu dis que tu as une erreurs dans l'erosion.... Ca ne serait pas une erreur du genre 'index out of range' ?

Si c'est le cas c'est que tu n'as surement pas definie la fonction bord2 du tutoriel.

Lis le en entier... tu verras normalement ca fonctionne.

>>> Tutoriel a lire absolument ICI <<<

Cordialement

compter le nbre de personne sur une image

Traitement d'images

Discussions similaires

Partager

Partager