Segmentation des mouvements optiques d'un fichier YUV

Version imprimable

17/04/2009, 11h54
ilisander

2 pièce(s) jointe(s)

Segmentation des mouvements optiques d'un fichier YUV

Bonjour à tous, :salut:
je suis nouveau ici et je me permets de vous demandez un peu d'aide :) j'ai un programme à faire sur un fichier de format YUV. Je dois effectuer ici une lecture du fichier en question en demandant à l'utilisateur de mettre le nombre de pixel lu en largeur et hauteur mais aussi de mettre le nombre d'image sur lequel on va lire le fichier. Je suis penché dessus depuis qq jours mais j'ai une erreur de segmentation. le printf ici sexcute mais juste pour la 1ère image puis ensuite ils disent erreur et le programme ne continue pas.
Si quelqu'un pourrait m'aider je le remercie d'avance :)

Ps: J'ai mis le code en pièce jointes => projetbis.c

J'ai aussi mis en pièce jointe le code qui compile sans la mise en fonction mais avec des valeurs de videos prédéfinie. => projet_base.c
17/04/2009, 14h16
diogene
Code:

1 2 3 4 5 6 7 8 int main(void) { int nb_long,nb_larg; int **tableau; .... Lecture(tableau,nb_long,nb_larg); return 0; }
tableau n'est pas un tableau, mais un pointeur (sur un pointeur sur un int)
Du coup

Code:

tab[a][b*c]=&pix;

plante en tentant d'écrire dans une zone non allouée.

Faire la différence :
un pointeur int * p n'est pas un tableau 1D de int
un pointeur int** p n'est pas un tableau 2D de int
Le nombre d'étoiles n'a rien à voir avec la dimension d'un tableau.

Tu codes en C99 ?
17/04/2009, 19h17
ilisander

Merci pour les conseils, je code sous éclipse. Il fautdrait faire une alloc dynamique avec un malloc?
17/04/2009, 19h56
diogene

Citation:

Il fautdrait faire une alloc dynamique avec un malloc?

Si le tableau comporte beaucoup d'éléments : oui
Si les dimensions du tableau ne sont pas fixées à la compilation mais à l'exécution : oui
Regarde cette entrée de la FAQ : "Comment allouer dynamiquement un tableau à 2 dimensions ?"
18/04/2009, 11h01
ilisander

Merci pour le faq, en fait je dois faire en sorte de prendre 3 paramètre en compte le nombre d'image de la video que je vais apeller a puis le largeur et la hauteur de l'image qui seront i et j cela devrait donc donner un tableau comme ceci tab[a][i*j]. Le faq que j'ai lu il ne prenne en compte que les 2 dimensions du tableau avec 2 valeurs tandis que moi j'en ai 3 donc je ne vois pas trop comment faire :s
Il y a aussi dans le main le tableau je sais pas comment le déclarer.
Je vous remercie.
18/04/2009, 15h40
diogene

Citation:

comme ceci tab[a][i*j].

ou encore tab[a][i][j] avec un tableau à trois dimensions.
L'inconvenient d'utiliser un tableau à plusieurs dimensions, est le passage de ce tableau en argument d'une fonction : il faut préciser dans la déclaration du paramètre correspondant les dimensions du tableau (sauf celle la plus à gauche a). Alors la fonction n'est pas utilisable pour les autres valeurs de ces dimensions.

La méthode de la FAQ construit un tableau à une dimension (de a pointeurs), donc on n'a aucune dimension à préciser lors de la définition du paramètre. Si on a besoin de connaître les dimensions (ce qui est très courant), il suffit de les passer également en paramètres de la fonction. Elle permet en plus, ce qui est loin d'être désagréable, d'utiliser la notation [] pour accéder aux éléments.

Citation:

...tab[a][i*j]. Le faq que j'ai lu il ne prenne en compte que les 2 dimensions du tableau avec 2 valeurs tandis que moi j'en ai 3

Non, ce tableau est à deux dimensions : (a) et (i*j) et on peut appliquer la méthode de la faq sans modifications.

Avec un tableau à trois dimensions, tab[a][i][j], la même méthode s'applique en la généralisant un peu :
- on crée un tableau de a pointeurs int**
- on initialise chaque pointeur int** en créant un tableau de i pointeurs int*
- on initialise chaque pointeur int* en créant un tableau de j int

jte remercie diogène pour tes conseils qui me sont précieux :):yaisse2:

Voilà ce que j'ai fait et çà compile en faisant un print pour afficher les valeurs, sinon là dans une deuxième fonction je dois calculer la moyenne de chaque pixel pour mettre ces valeurs dans un autre tableau que j'apelle TF (TabFond). Il faut donc que je réutilise les valeurs du tableau que j'ai fait dans la fonction lecture puis de les diviser par le nombre d'images. Je sais pas trop comment mettre tout çà en paramètre.

Code:

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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#include<stdlib.h>
#include<stdio.h>
 
int Lecture(int **tab,int h,int i,int j){
	FILE* fichier = NULL;
	int a,b,c,d,e,f,g;
	int pix[i*j];
	fichier = fopen("//home//richard//projet//foreman.yuv","r");
 
	if(fichier!=NULL){
 
		for(a=0;a<h;a++){
			tab[a] = malloc((i*j)*sizeof(int));
			for(b=0;b<i;b++){								
				for(c=0;c<j;c++){							
					fread(&pix,1,1,fichier);
					tab[a][b*c]=*pix;
					//printf("la valeur à l'image %d, pixel: avec longueur=%d et hauteur=%d est: %d \n",a+1,b,c,tab[a][b*c]);
				}
			}
			for(d=0;d<(i/2);d++){
				for(e=0;e<(j/2);e++){
					fread(&pix,1,1,fichier);
				}
			}
			for(f=0;f<(i/2);f++){
				for(g=0;g<(j/2);g++){
					fread(&pix,1,1,fichier);
				}
			}
		}
	fclose(fichier);
	}
	else{
		printf("Impossible d'ouvrir le fichier");
	}
	return tab[a][b*c];
}
 
void MoyennageFond(int *TF,int h, int i,int j){ //Cette fonction permet de faire une valeur moyenne pour chaque pixel de chaque image afin de stocker le tout dans un tableau de fond
	//Moyennage
	int k,l,m,som;
	for(k=0;k<j;k++){
		for(l=0;l<i;l++){
			som=0;
			TF = malloc((i*j)*sizeof(int));
			for(m=0;m<h;m++){
				som+=tab[m][k*l];
			}
			TF[k*l]=som/m;
			printf("la valeur moyenne  avec longueur=%d et largeur=%d est: %d \n",k,l,TF[k*l]);
		}
	}
}
 
 
 
int main(void){
	int **tableau;
	int *tabFond;
	int nb_img,nb_long,nb_larg;
 
	printf("Sur combien d'images voulez vous travailler? ");
	scanf("%d",&nb_img);
 
	printf("Quelle est le nombre de pixel en longueur?");
	scanf("%d",&nb_long);
 
	printf("Quelle est le nombre de pixel en largeur?");
	scanf("%d",&nb_larg);
 
	tableau = malloc(nb_img*sizeof(int *));
 
	Lecture(tableau,nb_img,nb_long,nb_larg);
	tabFond = malloc
 
	MoyennageFond(tableau,nb_img,nb_long,nb_larg,tabFond);
	return 0;
}

* D'abord, une généralité importante :
Le choix des identificateurs est important. C'est la première source d'informations pour celui qui lit le programme : il sait ce que représente chaque grandeur.
Ceci ne répond pas à ce critère :

Code:

int Lecture(int **tab,int h,int i,int j)

que représentent les paramètres h, i et j ? Pour le savoir, il faut se reporter à l'utilisation de la fonction ou étudier le code de la fonction.

Code:

int Lecture(int **tab,int nbImg,int hauteur,int largeur)

par exemple est plus parlant. On n'en est pas à économiser de la frappe clavier, mais à écrire un programme clair.
Code:

1 2 FILE* fichier = NULL; // oui, un identificateur clair int a,b,c,d,e,f,g; // non, que représentent ces grandeurs ????
* Autre remarque :

Code:

int pix[i*j];

n'est valable qu'en C99. Peu de compilateurs supportent complètement la norme C99 (et aucun je crois parmi ceux qui sont gratuits). C'est donc à éviter.

* Tu utilises un tableau 2D pour stocker tes données. Une des dimensions est utilisée pour construire un tableau d'images et l'autre représente une image complète. Par nature, une image n'est pas à 1D mais à 2D. Tu peut la représenter par un tableau 1D, à condition que tu fasses dans ton code la transposition 2D->1D dans le calcul des indices.
Code:

1 2 3 4 5 for(b=0;b<i;b++){ for(c=0;c<j;c++){ fread(&pix,1,1,fichier); tab[a][b*c]=*pix; ...
la valeur d'indice b*c n'est pas correcte : il faudrait quelque chose du genre b*j+c

Code:

int pix[i*j];

Pourquoi un tableau pour pix ?

* Cessons de critiquer et passons à des choses constructives et plus méthodiques :

- Ecrire une fonction qui construise, suivant la méthode de la FAQ, une image. On en aura besoin pour construire un paquet d'images et dans la fonction de moyennage. Elle aura pour prototype :

Code:

int** CreerImage(int pixelshauteur,int pixelslargeur);

et renverra le tableau créé.

- Pendant qu'on y est, écrire une fonction qui détruit une image. Son prototype peut être

Code:

void DetruireImage(int** image) ;

- L'information concernant une liste d'images est constituée de : le nombre d'images, les dimensions d'une image, le tableau des pointeurs sur les différentes images. On a tout intérêt à regrouper ces informations dans une structure, par exemple :
Code:

1 2 3 4 5 6 7 typedef struct { int nbImages; int hauteur; int largeur; int *** images; }TListeImage;
- Ecrire une fonction qui crée un paquet d'images :

Code:

TListeImage * CreerListeImage(int nbImg,int hauteur,int largeur);

Elle créera une structure TListeImage et renverra son adresse. Pour créer chaque image, elle fera appel à la fonction CreerImage().

- Pendant qu'on y est, écrire une fonction qui détruit une liste d'images. Son prototype peut être

Code:

void DetruireListeImage(TListeImage *listeimage);

et elle utilisera la fonction DetruireImage() pour détruire chaque image.

On dispose maintenant du matériel nécessaire pour passer au traitement proprement dit qui devrait ressembler à ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 int main(void) { TListeImage * listeimage; int ** tabFond; int nb_img,nb_haut,nb_larg; char nomfichier = "//home//richard//projet//foreman.yuv" ; printf("Sur combien d'images voulez vous travailler?\n"); scanf("%d",&nb_img); .... listeimage = CreerListeImage(nb_img,nb_haut,nb_larg); if(listeimage != NULL) { if(Lecture(nomfichier,listeimage)) { tabFond = MoyennageFond(listeimage); ..... } else printf("Erreur d'ouverture du fichier %s\n",nomfichier); DetruireListeImage(listeimage); } else printf("Erreur d'allocation memoire\n"); return 0; }

J'accepte sans problème les critiques, je suis débutant en C et donc tes critiques sont plutot des conseils.

Sinon pour la fonction de création d'image se présente t-elle comme ceci:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
int** CreerImage(int pixelshauteur,int pixelslargeur){
	int pix;	
	int i,j,d,e,f,g;
	for(i=0;i<pixelshauteur,i++){
		for(j=0;j<pixelslargeur;j++){
			fread(&pix,1,1,fichier);
			tab[i][j]=pix;
		}
	}
 
	for(d=0;d<(hauteur/2);d++){
		for(e=0;e<(largeur/2);e++){
			fread(&pix,1,1,fichier);
		}
	}
	for(f=0;f<(hauteur/2);f++){
		for(g=0;g<(largeur/2);g++){
			fread(&pix,1,1,fichier);
		}
	}
}

Citation:

tes critiques sont plutot des conseils

Oui, c'est bien comme ça qu'il faut l'entendre;

Citation:

Sinon pour la fonction de création d'image se présente t-elle comme ceci:

Sauf que
- tu as oublié de créer le tableau (tab)
- fichier n'est pas défini.
Je crois préférable de créer d'abord le tableau dans une fonction et de le remplir dans une autre.
Suivant la méthode de la FAQ : Comment allouer dynamiquement un tableau à 2 dimensions ? et en testant les allocations, on obtient quelque chose comme (plusieurs variantes sont possibles) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 int** CreerImage(int pixelshauteur,int pixelslargeur) { int i; int ** tab = malloc(pixelshauteur * sizeof(int *)); if(tab != NULL) // tester la réussite de l'allocation { // initialiser à NULL pour DetruireImage en cas d'échec ultérieur d'allocation for(i = 0; i < pixelshauteur; i++) tab[i] = NULL; for(i = 0; i < pixelshauteur; i++) { tab[i] = malloc(pixelslargeur * sizeof(int)); if(tab[i] == NULL) // tester l'échec de l'allocation { DetruireImage(tab,pixelshauteur); // Echec : détruire tout tab = NULL; // -> retourner NULL break; // quitter la boucle for } } } return tab; // renvoie NULL en cas d'échec }
Avec pour la fonction DetruireImage :
Code:

1 2 3 4 5 6 7 8 9 void DetruireImage(int** tab, int pixelshauteur) { int i; if(tab != NULL) { for(i = 0; i < pixelshauteur; i++) free(tab[i]) ; free(tab); } }
La suite concerne la création/destruction d'une liste d'images.

28/04/2009, 21h29
ilisander

Ok d'accord cette fonction jte remercie, par contre je vois pas trop comment faire là pour faire la création de la liste d'image.

j'essaye de faire ceci mais sinon je vois pas trop:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
typedef struct{
	int img;
	int width;
	int height;
	int ***images;
}
 
TListeImage * CreerListeImage(int nbImg,int hauteur,int largeur){
	int i,j;	
	for(i=0;i<TlisteImage.nbImages;i++){
		CreerImage(int pixelshauteur,int pixelslargeur);
	}
	return TlisteImage;
}

Fais un peu attention ! Beaucoup trop d'erreurs !

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
typedef struct{
	int img;
	int width;
	int height;
	int ***images;
} // et le nom du typedef, et le ;
TListeImage ;
 
TListeImage * CreerListeImage(int nbImg,int hauteur,int largeur){
	int i,j ; // j ne sert à rien !
// Il faut d'abord construire un TListeImage 
//             TListeImage * listeImage = malloc(sizeof *listeImage );
// TlisteImage est un type, pas une variable
// un TListeImage ne comporte pas de champ nbImages;	
	for(i=0;i<TlisteImage.nbImages;i++){
// Ce n'est pas ainsi qu'on appelle une fonction
// Il faut aussi stocker la valeur de retour de la fonction si on veut pouvoir s'en servir
		CreerImage(int pixelshauteur,int pixelslargeur);
	}
// On ne retourne pas un type mais une valeur
	return TlisteImage;
}