Bonjour, le but de ce programme est de reconstituer une image découpée en 512 bandellettes (shred). Il faut effectuer un "tri" d'une liste (inputList), de manière à obtenir la meilleure image possible (dans la liste pliste_finale).
Le programme utilise buildPicture.pl pour reconstituer cette image.
je sollicite votre aide, car la fonction du main se compile, mais ne s'execute pas lors du lancement de buildPicture.pl. Pouvez-vous m'éclairer svp.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
// usage :
// ./reverseShredderBasics_color < fileList.txt
// or
// ls shred*.txt | ./reverseShredderBasics_color
//then use buildPicture.pl to actualy create output picture
//////// useful string functions
void chop(char *str) {
int l = strlen(str)-1;
if ((l>=0)&&(str[l]=='\n'))
str[l]='\0';
}
//////////
typedef struct {
int size;
int *r;
int *g;
int *b;
} vector;
///////// vector functions
vector *vectorAllocate (int size) {
vector *v;
if ((v=(vector*)malloc(sizeof(vector)))==NULL)
exit(12);
if ((v->r = (int*)malloc(sizeof(int)*size))==NULL) {
exit(12);
}
if ((v->g = (int*)malloc(sizeof(int)*size))==NULL) {
exit(12);
}
if ((v->b = (int*)malloc(sizeof(int)*size))==NULL) {
exit(12);
}
v->size = size;
return v;
}
void vectorDestroy(vector *v) {
free(v->r);
free(v->g);
free(v->b);
free(v);
}
float vectorDistance(vector *v1, vector *v2) {
float s=0;
int i;
for(i=0;i<v1->size;i++) {
s += fabs((float)(v1->r[i] - v2->r[i]));
s += fabs((float)(v1->g[i] - v2->g[i]));
s += fabs((float)(v1->b[i] - v2->b[i]));
}
s /= (float)v1->size;
return s;
}
///////// end of vector functions
typedef struct {
char id[1024];
vector *left;
vector *right;
} shred;
////////// shred functions
shred *shredAllocate(int size) {
shred *s;
if ((s = (shred*)malloc(sizeof(shred)))==NULL)
exit(12);
s->left = vectorAllocate(size);
s->right = vectorAllocate(size);
return s;
}
void shredDestroy(shred *s) {
vectorDestroy(s->left);
vectorDestroy(s->right);
}
float shredDistance(shred *s1, shred *s2) {
return vectorDistance(s1->right,s2->left);
}
////////// end of shred functions
///////////// cell*
typedef struct cell_ {
shred *elt;
struct cell_ *next;
struct cell_ *previous;
} cell;
cell* insertFirst(cell* l, shred *elt) { //insert at the beginin of the cell*
cell *c;
// allocation of cell
c = (cell*)malloc(sizeof(cell));
if (c == NULL)
return NULL;
c->elt = elt; // set value
c->next = l;
c->previous = NULL;
if (l !=NULL)
l->previous = c;
return c;
}
cell* insertLast(cell* l, shred *elt) { // beware this function returns ptr to last elt !
cell *c;
// allocation of cell
c = (cell*)malloc(sizeof(cell));
if (c == NULL)
return NULL;
c->elt = elt; // set value
c->previous = l;
c->next = NULL;
if (l!=NULL)
l->next = c;
return c;
}
cell* popFirst(cell* l) {
cell *c;
if (l==NULL)
return NULL;
c = l;
l = l->next;
if (l !=NULL)
l->previous = NULL;
free(c);
return l;
}
cell* pop(cell* l,cell* c) { // pop cell c form cell* l
cell* tmp;
if (c==NULL)
return c;
if (c->previous)
c->previous->next = c->next;
if (c->next)
c->next->previous = c->previous;
tmp = c->next;
free(c);
if (c==l) // pop first elt !
return tmp;
return l;
}
int listSize(cell* l) {
int i = 0;
while(l != NULL) {
i++;
l = l->next;
}
return i;
}
void printList(cell* l) {
while (l!=NULL) {
printf("%s\n",l->elt->id);
l = l->next;
}
}
/////////////// end of cell* functions
/////////// main functions
cell* loadVectors() {
FILE *inVector;
char buffer[1024], filename[1024];
cell *l=NULL;
cell *first;
int i, firstOne;
shred *s;
firstOne = 1;
while (fgets(filename,1024,stdin)) {
chop(filename);
//printf("reading vector file : %s\n",filename);
if ((inVector = fopen(filename,"r" ))==NULL)
exit(12);
fgets(buffer,1024,inVector);
i = 0;
/*while (!(buffer[i]>'0' && buffer[i] < '9'))
i++;
i = atoi(buffer+i);*/
sscanf(buffer,"shred length %d\n",&i);
s = shredAllocate(i);
strcpy(s->id,filename);
i = 0;
while (fgets(buffer,1024,inVector)) {
sscanf(buffer,"%i %i %i %i %i %i\n", &(s->left->r[i]),&(s->left->g[i]),&(s->left->b[i]),&(s->right->r[i]),&(s->right->g[i]),&(s->right->b[i]));
i++;
}
fclose(inVector);
l = insertLast(l,s);
if (firstOne)
first = l;
firstOne = 0;
}
return first;
}
int main(int argc,char **argv) {
cell* inputList = NULL;
//printf("coucou" );
inputList = loadVectors(); // use stdin
//printf("coucou2" );
float distance;
float distance_comparaison_droite=9999;
float distance_comparaison_droite_liste_finale;
float distance_comparaison_gauche;
cell * minD;
//declaration et initialisation de la liste finale
cell * pliste_finale;
pliste_finale=NULL;
pliste_finale=insertFirst(pliste_finale,inputList->elt);
inputList=popFirst(inputList);
//creation de pointeur pour se deplacer dans les listes
cell *paux;
cell *paux2;
cell *paux3;
int temp = listSize(pliste_finale);
printf("%d",temp);
while(listSize(inputList)!=0)
{
printf("je rentre dans la bouvle1" );
paux=inputList;
paux2=pliste_finale;
//j'ai pris un elt de inputList et je calcule la distance minimale avec les shreds de la liste finale.
//je mémorise l adresse du shred correspondant
int i=0;
while(pliste_finale->next!=NULL)
{
distance=shredDistance(paux->elt,paux2->elt);
if(distance<distance_comparaison_droite_liste_finale)
{
minD=paux2;
distance_comparaison_droite_liste_finale=distance;
}
paux2=paux2->next;
}
//pour ce shred je regarde si je place le shred de la inputList a droite ou a gauche
distance_comparaison_gauche = shredDistance( minD->elt,paux2->elt);
if(distance_comparaison_gauche<distance_comparaison_droite)
{
paux3=paux2;
paux2=insertFirst(paux2,minD->elt);
paux2->previous=paux3;
//si on ajoute a gauche du premier elt on place paux2 dans pliste_finale
if(paux2==pliste_finale)
{
pliste_finale=paux2;
}
}
else
{
paux3=paux2;
paux2=paux2->next;
paux2=insertFirst(paux2,minD->elt);
paux2->previous=paux3;
}
paux=paux->next;
inputList=popFirst(inputList);
}
///////////////////////////////
// exemple of code comparing the 2 firsts shreds :
//
// float dist = shredDistance(inputList->elt,inputList->next->elt);
//
printList(inputList);
//printList(pliste_finale);
return 0;
}
Merci de votre aide.
Message édité par Alpha002 le 24-11-2006 à 11:38:33