Discussion :

[millie]

Bonjour,

Voici 2 méthodes pour créer des Thumbnails à partir d'un BufferedImage.

On utilise un SCALE_SMOOTH pour avoir une image réduite "potable" niveau visualisation.

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
public static BufferedImage reduceImage(BufferedImage input, int newwidth,
			int newheight) {
		BufferedImage out = null;
		//on choisie le type de couleur suivant le nombre de composants
		if(input.getColorModel().getNumColorComponents() == 1)
		 out = new BufferedImage(newwidth, newheight, BufferedImage.TYPE_BYTE_GRAY);
		else
			out = new BufferedImage(newwidth, newheight, BufferedImage.TYPE_INT_RGB);
 
		Graphics2D g = out.createGraphics();
		System.err.println("Temp color model : " + input.getColorModel());
		Image scaled = input.getScaledInstance(newwidth, newheight,	Image.SCALE_SMOOTH); //on utilise un SCALE_SMOOTH pour obtenir une petite image correcte
		g.drawImage(scaled, 0, 0, out.getWidth(), out.getHeight(), null);
		g.dispose();
		return out;
	}
 
	public static BufferedImage reduceImage(BufferedImage input, float factor) {
		int newwidth = (int) (((double) input.getWidth()) * factor);
		int newheight = (int) (((double) input.getHeight()) * factor);
		return reduceImage(input, newwidth, newheight);
	}

[eclesia]

pour la methode avec parametre factor, tu pourrais passer plus simplement par une modification du affinetransform de l'object graphic2D. (c'est aussi meilleur niveau perf)

[millie]

Mais ça fait des thumbnails tout pourri...

Méthode classique avec interpolation simple


Méthode avec le smooth

[eclesia]

il faut penser aux hints java2d .

http://java.sun.com/docs/books/tutor...d/quality.html

celui la en particulier pour tes images : KEY_INTERPOLATION

[millie]

il faut penser aux hints java2d .

http://java.sun.com/docs/books/tutor...d/quality.html

celui la en particulier pour tes images : KEY_INTERPOLATION

T'inquiètes, j'ai tout essayé avec des interpolations linéaires/bilinéaires, ça ne donnait pas des résultats aussi bon au moins sur des images de type texte

L'image mauvaise que tu vois, je crois que c'était une interpolation linéaire (et bilinéaire, c'était pas beaucoup mieux)

Mais ça peut effectivement dépendre de l'image source. Pour une photo, c'est OK, pour une image avec plein de détails comme du texte, c'est pas bon


EDIT : Ah, tu parlais du KEY_TEXT ?

[sinok]

Euh, mieux vaut en général ne pas utiliser le getScaledInstance (oui je sais bis répétita), trop lent dans une appli pour le calcul de thumbnails.

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

La manière de procéder à recommander serait plutôt la suivante:

Il ne faut JAMAIS utiliser getScaledInstance(). JAMAIS. Cette methode est 20 a 30 fois plus lente que l'autre solution :

Code :

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

1
2
3
4
5
6
7
 
Image imageAReduire = ...;
// ...
BufferedImage image = new BufferedImage(BufferedImage.TYPE_INT_ARGB, imageAReduire.getWidth(null), imageAReduire.getHeight(null));
Graphics2D g2 = image.createGraphics();
g2.drawImage(imageAReduire, 0, 0, nouvelleLargeur, nouvelleHauteur, null);
g2.dispose();

La methode Graphics.drawImage() permet de redimensionner l'image grace a la carte graphique. Pour avoir un plus joli resultat tu peux rajouter cela avant le drawImage() :

Code :

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

1
2
 
g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);

Le resultat ne sera agreable que si ta version reduite de l'image a des dimensions proches de celles d'origine divisees par deux. Si tu reduis plus il faut utiliser une approche proche de la technique du mip mapping :

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
 
        public static BufferedImage createThumbnail(BufferedImage image, int requestedThumbSize) {
        float ratio = (float) image.getWidth() / (float) image.getHeight();
        int width = image.getWidth();
        BufferedImage thumb = image;
 
        do {
            width /= 2;
            if (width < requestedThumbSize) {
                width = requestedThumbSize;
            }
 
            BufferedImage temp = new BufferedImage(width, (int) (width / ratio), BufferedImage.TYPE_INT_ARGB);
            Graphics2D g2 = temp.createGraphics();
            g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                                RenderingHints.VALUE_INTERPOLATION_BILINEAR);
            g2.drawImage(thumb, 0, 0, temp.getWidth(), temp.getHeight(), null);
            g2.dispose();
 
            thumb = temp;
        } while (width != requestedThumbSize);
 
        return thumb;
    }

Et non, cette solution n'est pas vraiment plus lente que celle en une seule etape