Resize image [Urgent !]

Bonjour,

Est-ce que vous avez une idée de l'algo (enfin le code :D) en C qui donnerait la possibilité de réduire ou agrandir une image !

Merci !

Yep, bien sûr:
Réduction = moyenne des pixels voisins
Agrandissement = interpolation
Jettes un oeil sur ma source

@+
Buno
----------------------------------------
L'urgent est fait, l'impossible est en cours. Pour les miracles, prévoir un délai...

Salut !

Sur ta source il n'y a pas de fonction pour modifier la taille de l'image. De plus avec un tableau à 2 dimensions c'est simple. Mais lorsque tu doit gérer un tableau à une dimension c'est un plus chaud par exemple lorsque tu veux agrandir sur la longueur et la hauteur.

voici la structure :

typdef struct Timage
{
  int w;
  int h;
  unsigned char * data;
} Timage;

Sur ta source il n'y a pas de fonction pour modifier la taille de l'image
-> ah oups, sorry...Je me sens c** du coup

un tableau à une dimension c'est un plus chaud
-> bof. Si tu connais la hauteur et la largeur de ton image, aucun souci.
Au lieu d'accéder à un pixel comme ça:  bitmap[i][j], tu dois faire bitmap[i*largeur+j].
ça allonge l'écriture, certes, mais le traitement est le même

@+
Buno
----------------------------------------
L'urgent est fait, l'impossible est en cours. Pour les miracles, prévoir un délai...

Je teste ça et je verrai !

Merci bien ;)

le truc c'est que lors de l'agrandissement de l'image, je fonctionne par coefficient d'agrandissement.
Exemple : coeffW = newWidth/oldWidth;
le problème c'est que le coeffW correspondra parfois à une valeur à virgule flottante donc pour l'interpolation des pixel reste difficile.

tu vois ce que je veux dire ou pas ? :D

Hello,
Désolé, je ne vois pas ce que tu veux dire. Pourrais-tu être plus précis, s'il te plaît?

@+
Buno
----------------------------------------
L'urgent est fait, l'impossible est en cours. Pour les miracles, prévoir un délai...

Voilà une fonction permettant de modifier la résolution d'une image :
/**
   * Resize jpg file
   *
   * @params
   *    Timage image - current image to edit
   *    int height - new height
   *    int width - new width
   */
int resize(Timage image, unsigned int height, unsigned int width)
{
    /* if the image is not exist  this function will return -1 as error value */
    if (image == NULL) return -1;
   
    /* on test si les les nouvelles dim. sont similaire au anciennes dim. */
    if (image->h == height && image->w == width) return 1;

    int x,y, * xarray;
    unsigned char  ** yarray, *ptr, *ptr2, *ptr22;
    unsigned char * new_data = (unsigned char *)malloc(height * width * 3 * sizeof(unsigned char *));
    int l,  r, m, pos, inc, w3;
   
    /* verify new_data */
    if (!new_data)
    {
        printf("Erreur d'allocation de l'image\n");
        return -1;
    }

    /* verify xarray */
     xarray = (int *)malloc(sizeof(int) * width);   
    if (!xarray)
    {
        printf("Erreur d'allocation de l'image de coord. X\n");
        return -1;
    }
   
    /* verify yarray */
    yarray = (unsigned char **)malloc(sizeof(unsigned char *) * height);     
    if (!yarray)
    {
        printf("Erreur d'allocation de l'image de coord. Y\n");
        /* on libere la memoire non utilisé */
        free(new_data);
        free(xarray);
        return -1;
    }

  ptr22 = image->data;
  w3 = image->w * 3;
  inc = 0;
  l = 0;
  r = 0;
  m = width - l - r;

   
  /* décalage binaire de 16 byte */
  inc = (image->w << 16) / m;
 
  /* position 0 */
  pos = 0;
 
  /* on parcourt d'abord tous les valeurs de coordonnées x */
  for (x = l; x < l + m; x++) {
 
    /* */
    xarray[x] = (pos >> 16) + (pos >> 16) + (pos >> 16);
   
    /* incrementation de la position  */
    pos += inc;
  }
 
  pos = (image->w - r) << 16;
  for (x = width - r; x < width; x++) {
    xarray[x] = (pos >> 16) + (pos >> 16) + (pos >> 16);
    pos ++;
  }
 
  l = 0;
  r = 0;
  m = height - l - r;
 
  if (m > 0)
    inc = (image->h << 16) / m;
 
  pos = 0;
 
  for (x = l; x < l + m; x++) {
    yarray[x] = ptr22 + ((pos >> 16) * w3);
    pos += inc;
  }
 
  pos = (image->h - r) << 16;
  for (x = height - r; x < height; x++) {
    yarray[x] = ptr22 + ((pos >> 16) * w3);
    pos ++;
  }
 
  ptr = new_data;
  for (y = 0; y < height; y++) {
    for (x = 0; x < width; x++) {
      ptr2 = yarray[y] + xarray[x];
      *ptr++ = (int)*ptr2++;
      *ptr++ = (int)*ptr2++;
      *ptr++ = (int)*ptr2;
    }
  }
   
    image->h = height;
    image->w = width;
    image->data = new_data;
   
    /* on libere la mémoire */
    free(xarray);
    free(yarray);
   
       
    return 1;
}

je rappel que je me suis aidé d'un autre algo.