[AffineTransform]Qualité de redimensionnement

Version imprimable

Bonjour,
j'ai besoin de redimensionner des images de grandes tailles en beaucoup plus petite, le problème est que ces images contiennent essentiellement du texte.
Hors, le texte devient vite illisible alors qu'il faudrait qu'il reste très clair.

Par toute logique une image de grande taille devrait me donner des qualités respectables, mais ca n'est pas le cas, je me demande alors si cela vient de ma façon de faire ou alors de l'algorithme du JDK.
Code:

1 2 3 4 5 6 7 8 AffineTransform tx = new AffineTransform(); double ratio = (double)newWidth/srcB.getWidth(); tx.scale(scaleWidth, scaleHeight); AffineTransformOp op = new AffineTransformOp(tx,getHintsByQuality(quality)); BufferedImage bi = op.filter(srcB, imgType.createBufferedImage(newWidth,newHeight)); return bi;
J'ai éssayé aussi de cette façon :
Code:

1 2 3 4 5 BufferedImage bi = imgType.createBufferedImage(newWidth,newHeight); Graphics2D g = bi.createGraphics(); g.setRenderingHints(getHintsByQuality(quality)); g.drawImage(srcB, 0, 0 ,newWidth,newHeight, null);
Voici des exemples d'images, même si c'est un mauvais exemple car le texte est déjà trop fin. En temps normal le texte est bien plus gros, mais le problème est le même, j'ai un rendu de redimensionnement très mauvais par rapport à des outils (Gimp, Photoshop,..) ou avec d'autres librairies (GDLib).
original.png
En 1500
En 1100
En 1100

Auriez-vous une idée, une solution ?

Cordialement,
Thomas

01/09/2009, 16h47
sinok

Commence par te diriger vers les techniques décrites dans ce tuto:

http://today.java.net/pub/a/today/20...dinstance.html

Puis dans le pire des cas dirige toi vers vers un Image.getScaledInstance avec SCALE_SMOOTH comme hint
02/09/2009, 02h23
bouye

getScaledInstance() c'est poa bien...

Ca sent le besoin de passer un filtre (sharpen ?) sur l'image apres redimensionnement (voir la classe Kernel).

Ah vi et quel etaient les rendering hints utilises pour le redimensionnement (et plus specifiquement le RenderingHints.KEY_INTERPOLATION) ?

En fouillant sur le forum on doit egalement trouver la methode de redimensionnement successifs par 2 en utilisant RenderingHints.VALUE_INTERPOLATION_BILINEAR qui est plus rapide et donne de meilleurs resultats qu'un unique redimensionnement avec RenderingHints.VALUE_INTERPOLATION_BICUBIC. Ah vi il est egalement indique plus bas dans l'article.

Tout d'abord, merci pour vos réponses !

Effectivement l' article traite très bien le sujet, je vais faire quelques testes autour de la technique de multi-step.
Et comme la performance n'est pas prioritaire, je vais essayer un "SCALE_SMOOTH" pour voir le rendu.

Les Hints utilisés dépendent de mon paramètre de qualité, mais aucun ne convient.
Code:

1 2 3 4 5 6 hints.put(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON); hints.put(RenderingHints.KEY_TEXT_ANTIALIASING,RenderingHints.VALUE_TEXT_ANTIALIAS_DEFAULT); hints.put(RenderingHints.KEY_RENDERING,RenderingHints.VALUE_RENDER_QUALITY); hints.put(RenderingHints.KEY_INTERPOLATION,RenderingHints.VALUE_INTERPOLATION_BICUBIC); ...
Je suis actuellement, un peu passé au-dessus du problème en prenant des images sources moins large. Mais le résultat n'est pas super satisfaisant quand même.
Et au contraire de ce que tu me dit bouye, j'avai plutôt pensé à un filtre "ConvolveOp" très faible pour lisser les bords mais je comparerai les deux résultats.

Je reviendrai dire ce qu'il en est ! Merci !

Effectivement cette nouvelle méthode de redimensionement produit un rendu plus propre ! De plus, la performance n'est pas mise à défaut, c'est parfait, merci !

Voilà donc la méthode que j'utilise maintenant :

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
 
public static BufferedImage getScaledInstance(final BufferedImage img,final int targetWidth,final int targetHeight,final RenderingHints hint,final boolean higherQuality,final float resizeStepRate)
    {
        int type = (img.getTransparency() == Transparency.OPAQUE) ?
    				BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;
        BufferedImage ret = (BufferedImage)img;
        int w, h;
        if (higherQuality) {
            // Use multi-step technique: start with original size, then
            // scale down in multiple passes with drawImage()
            // until the target size is reached
            w = img.getWidth();
            h = img.getHeight();
        } else {
            // Use one-step technique: scale directly from original
            // size to target size with a single drawImage() call
            w = targetWidth;
            h = targetHeight;
        }
 
        do {
            if (higherQuality && w > targetWidth) {
                w /= resizeStepRate;
                if (w < targetWidth) {
                    w = targetWidth;
                }
            }
 
            if (higherQuality && h > targetHeight) {
                h /= resizeStepRate;
                if (h < targetHeight) {
                    h = targetHeight;
                }
            }
 
            BufferedImage tmp = new BufferedImage(w, h, type);
            Graphics2D g2 = tmp.createGraphics();
            g2.setRenderingHints(hint);
            g2.drawImage(ret, 0, 0, w, h, null);
            g2.dispose();
 
            ret = tmp;
        } while (w != targetWidth || h != targetHeight);
 
        return ret;
    }