Discussion :

[ryosnake]

Bonjour à tous, étant à la recherche d'un algo permettant de redimensionner une image, je suis tombé sur la fonction suivante implémentée en Java. Ca fonctionne très bien, mais le problème c'est que je ne comprend pas comment ça fonctionne...

Code :

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
 
private static Image resizeImage(Image src, int screenWidth, int screenHeight)
    {
        int srcWidth = src.getWidth();
        int srcHeight = src.getHeight();
        Image tmp = Image.createImage(screenWidth, srcHeight);
        Graphics g = tmp.getGraphics();
        int ratio = (srcWidth << 16) / screenWidth;
        int pos = ratio >> 1;
 
        // Horizontal Resize
        for (int x = 0; x < screenWidth; x++)
        {
            g.setClip(x, 0, 1, srcHeight);
            g.drawImage(src, x - (pos >> 16), 0, Graphics.LEFT | Graphics.TOP);
            pos += ratio;
        }
 
        Image resizedImage = Image.createImage(screenWidth, screenHeight);
        g = resizedImage.getGraphics();
        ratio = (srcHeight << 16) / screenHeight;
        pos = ratio >> 1;
 
        //Vertical resize
        for (int y = 0; y < screenHeight; y++) {
            g.setClip(0, y, screenWidth, 1);
            g.drawImage(tmp, 0, y - (pos >> 16), Graphics.LEFT | Graphics.TOP);
            pos += ratio;
        }
 
        return resizedImage;
    }

En particulier, ce décalage de bits de 16 qui est apparemment la clé de l'algo mais je ne saisis pas du tout comment ça fonctionne.

Merci par avance.

[pseudocode]

En particulier, ce décalage de bits de 16 qui est apparemment la clé de l'algo mais je ne saisis pas du tout comment ça fonctionne.

Cette partie est un hack sauvage pour éviter l'arithmétique à virgule flottante, et n'utiliser que des calculs sur les entiers (plus rapide).

au lieu de faire

Code java :

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

double ratio = (double)srcWidth / (double)screenWidth;

qui nous donnerait surement un ratio non entier, on calcule le ratio multiplié par 2^16

Code java :

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

double ratio = (double)(srcWidth*2^16) / (double)screenWidth;

dont on ne garde que la partie entiere. On perd alors la partie fractionnaire mais ca ne nous fait qu'une erreur de 1/2^16 qui est très acceptable

Code java :

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

int ratio = (srcWidth*2^16) / screenWidth;

Et comme, en binaire, une puissance entière est équivalente a un décalage

Code java :

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

int ratio = (srcWidth << 16) / screenWidth;

bien sur, il ne faudra pas oublier de rediviser par 2^16 (= décaler de 16 dans l'autre sens) quand on utilise ce ratio

[ryosnake]

Ok, merci beaucoup.

Lorsqu'on a la réponse sous les yeux, ça paraît tout de suite évident.
Finalement, je n'y était pas du tout et ce "hack sauvage" n'est en aucun cas la clé de l'algo. J'ai été obnubilé par ceci et du coup je n'ai pas compris que c'était tout le reste qui était important.
D'ailleurs, cet algo est intéressant et simple bien que le fait de construire une image intermédiaire n'est pas forcément optimal, je vais regardé si on peut faire ça en une fois.

Encore merci