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.

- balises code stp
- quelle est ta sortie ?

La sortie, si c'est ce que tu demandes, c'est pliste_finale, c'est à dire la liste qui a reconstitué l'image.
Par contre je ne comprends pas ce que t'entends par balise du code.

extrait des regles du forum :
 

Pour les balises de code, il s'agit d'utiliser [code=C][/code] avec ton code entre ces deux balises, ce qui permet de rendre ton code lisible par les forumeurs.

Sinon j'ai réalisé un copier-coller de ton code, pour le compiler, et j'obtiens ceci :

Il y a surement deux ou trois choses à corriger. Je ne suis pas allé plus loin dans l'analyse, il faudrait que tu isoles l'erreur et que tu nous dises précisément ce qui ne fonctionne pas.

apparement il y a un problème dans le main au niveau de la boucle while, je suis en train de réessayer un autre prototype de fonction. J'ai justement une question à ce sujet, je pensai a un autre algorithme qui trouverait la bandelette tout a gauche (de la photo) et ensuite coller les bandelettes (à droite) correspondant à la plus petite distance (shred qui se colle les une à coté des autres). Cependant comme les distances sont calculées en valeur absolue, est il réellement possible de trouver la premiere bandelette( distance avec toutes les autres la plus improbable).