Comment redimensionner un BufferedImage

AffineTransformOp offre la possibilité de choisir le type d'interpolation.

BufferedImage before = getBufferedImage(encoded);
int w = before.getWidth();
int h = before.getHeight();
BufferedImage after = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
AffineTransform at = new AffineTransform();
at.scale(2.0, 2.0);
AffineTransformOp scaleOp = 
   new AffineTransformOp(at, AffineTransformOp.TYPE_BILINEAR);
after = scaleOp.filter(before, after);

Le fragment ci dessous illustre rééchantillonnage, pas recadrage; ce réponse adresses de la question; quelques exemples sont examinés ici.

Comme @Bozho dit, vous voudrez probablement utiliser getScaledInstance.

De comprendre comment grph.scale(2.0, 2.0) fonctionne cependant, vous pourriez avoir un coup d'oeil à ce code:

import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.*;

import javax.imageio.ImageIO;
import javax.swing.ImageIcon;


class Main {
    public static void main(String[] args) throws IOException {

        final int SCALE = 2;

        Image img = new ImageIcon("duke.png").getImage();

        BufferedImage bi = new BufferedImage(SCALE * img.getWidth(null),
                                             SCALE * img.getHeight(null),
                                             BufferedImage.TYPE_INT_ARGB);

        Graphics2D grph = (Graphics2D) bi.getGraphics();
        grph.scale(SCALE, SCALE);

        //everything drawn with grph from now on will get scaled.

        grph.drawImage(img, 0, 0, null);
        grph.dispose();

        ImageIO.write(bi, "png", new File("duke_double_size.png"));
    }
}

Donné duc.png:

il produit duke_double_size.png:

Si vous n'avez pas l'esprit à l'aide d'une bibliothèque externe, Thumbnailator pouvez effectuer la mise à l'échelle de BufferedImages.

Thumbnailator prendra en charge la Java 2D de traitement (comme l'utilisation de Graphics2D des le rendu des conseils) de sorte qu'une simple API fluent appel peut être utilisé pour redimensionner les images:

BufferedImage image = Thumbnails.of(originalImage).scale(2.0).asBufferedImage();

Bien que Thumbnailator, comme son nom l'indique, est orientée vers le rétrécissement des images, il va faire un travail décent agrandissement d'images, en utilisant la méthode d'interpolation bilinéaire dans son défaut resizer mise en œuvre.

---

Disclaimer: je suis le responsable de la Thumbnailator bibliothèque.

À l'échelle d'une image, vous devez créer une nouvelle image et dessiner. Une façon est d'utiliser l' filter() méthode d'un AffineTransferOp, comme l'a suggéré ici. Cela vous permet de choisir la technique d'interpolation.

private static BufferedImage scale1(BufferedImage before, double scale) {
    int w = before.getWidth();
    int h = before.getHeight();
    //Create a new image of the proper size
    int w2 = (int) (w * scale);
    int h2 = (int) (h * scale);
    BufferedImage after = new BufferedImage(w2, h2, BufferedImage.TYPE_INT_ARGB);
    AffineTransform scaleInstance = AffineTransform.getScaleInstance(scale, scale);
    AffineTransformOp scaleOp 
        = new AffineTransformOp(scaleInstance, AffineTransformOp.TYPE_BILINEAR);

    scaleOp.filter(before, after);
    return after;
}

Une autre façon est de simplement dessiner l'image d'origine dans la nouvelle image, à l'aide d'un détartrage à faire la mise à l'échelle. Cette méthode est très similaire, mais il explique également comment vous pouvez dessiner ce que vous voulez dans l'image finale. (Je l'ai mis dans une ligne vide où les deux méthodes diffèrent.)

private static BufferedImage scale2(BufferedImage before, double scale) {
    int w = before.getWidth();
    int h = before.getHeight();
    //Create a new image of the proper size
    int w2 = (int) (w * scale);
    int h2 = (int) (h * scale);
    BufferedImage after = new BufferedImage(w2, h2, BufferedImage.TYPE_INT_ARGB);
    AffineTransform scaleInstance = AffineTransform.getScaleInstance(scale, scale);
    AffineTransformOp scaleOp 
        = new AffineTransformOp(scaleInstance, AffineTransformOp.TYPE_BILINEAR);

    Graphics2D g2 = (Graphics2D) after.getGraphics();
    //Here, you may draw anything you want into the new image, but we're
    //drawing a scaled version of the original image.
    g2.drawImage(before, scaleOp, 0, 0);
    g2.dispose();
    return after;
}

Addendum: Résultats

Pour illustrer les différences, j'ai comparé les résultats des cinq méthodes ci-dessous. Voici ce que les résultats ressemblent, mis à l'échelle à la fois en haut et en bas, le long avec des données de performance. (Le rendement varie de l'un à l'autre, afin de prendre ces seuls chiffres bruts des lignes directrices.) L'image du haut est l'original. Je échelle double de la taille et de la moitié de la taille.

Comme vous pouvez le voir, AffineTransformOp.filter(), utilisé dans scaleBilinear(), est plus rapide que la norme de méthode de dessin de Graphics2D.drawImage() dans scale2(). Aussi l'interpolation Bicubique est le plus lent, mais donne de meilleurs résultats lors de l'expansion de l'image. (Pour la performance, il ne doit être comparé avec scaleBilinear() et scaleNearest().) Bilinéaire semble être meilleur pour réduire l'image, même si c'est une question difficile. Et NearestNeighbor est le plus rapide, avec les pires résultats. Bilinéaire semble être le meilleur compromis entre vitesse et qualité. Le Image.getScaledInstance(), appelé dans le questionable() méthode, fait très mal, et a renvoyé le même de faible qualité en tant que NearestNeighbor. (Les chiffres de la Performance sont uniquement donnés à l'expansion de l'image.)

public static BufferedImage scaleBilinear(BufferedImage before, double scale) {
final int interpolation = AffineTransformOp.TYPE_BILINEAR;
return scale(before, scale, interpolation);
}
public static BufferedImage scaleBicubic(BufferedImage before, double scale) {
final int interpolation = AffineTransformOp.TYPE_BICUBIC;
return scale(before, scale, interpolation);
}
public static BufferedImage scaleNearest(BufferedImage before, double scale) {
final int interpolation = AffineTransformOp.TYPE_NEAREST_NEIGHBOR;
return scale(before, scale, interpolation);
}
@NotNull
private static 
BufferedImage scale(final BufferedImage before, final double scale, final int type) {
int w = before.getWidth();
int h = before.getHeight();
int w2 = (int) (w * scale);
int h2 = (int) (h * scale);
BufferedImage after = new BufferedImage(w2, h2, before.getType());
AffineTransform scaleInstance = AffineTransform.getScaleInstance(scale, scale);
AffineTransformOp scaleOp = new AffineTransformOp(scaleInstance, type);
scaleOp.filter(before, after);
return after;
}
/**
* This is a more generic solution. It produces the same result, but it shows how you 
* can draw anything you want into the newly created image. It's slower 
* than scaleBilinear().
* @param before The original image
* @param scale The scale factor
* @return A scaled version of the original image
*/
private static BufferedImage scale2(BufferedImage before, double scale) {
int w = before.getWidth();
int h = before.getHeight();
//Create a new image of the proper size
int w2 = (int) (w * scale);
int h2 = (int) (h * scale);
BufferedImage after = new BufferedImage(w2, h2, before.getType());
AffineTransform scaleInstance = AffineTransform.getScaleInstance(scale, scale);
AffineTransformOp scaleOp
= new AffineTransformOp(scaleInstance, AffineTransformOp.TYPE_BILINEAR);
Graphics2D g2 = (Graphics2D) after.getGraphics();
//Here, you may draw anything you want into the new image, but we're just drawing
//a scaled version of the original image. This is slower than 
//calling scaleOp.filter().
g2.drawImage(before, scaleOp, 0, 0);
g2.dispose();
return after;
}
/**
* I call this one "questionable" because it uses the questionable getScaledImage() 
* method. This method is no longer favored because it's slow, as my tests confirm.
* @param before The original image
* @param scale The scale factor
* @return The scaled image.
*/
private static Image questionable(final BufferedImage before, double scale) {
int w2 = (int) (before.getWidth() * scale);
int h2 = (int) (before.getHeight() * scale);
return before.getScaledInstance(w2, h2, Image.SCALE_FAST);
}