Come scalare un BufferedImage

Question

Seguendo le javadocs, ho cercato di scalare un BufferedImage senza successo qui è il mio codice:

BufferedImage image = MatrixToImageWriter.getBufferedImage(encoded); 
Graphics2D grph = image.createGraphics(); 
grph.scale(2.0, 2.0); 
grph.dispose(); 

non riesco a capire il motivo per cui non funziona, qualsiasi aiuto?

Answer 1

AffineTransformOp offre l'ulteriore flessibilità di scegliere il tipo di interpolazione.

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); 

Alcuni esempi correlate sono esaminate here e here.

Answer 2

scale(..) funziona un po 'diverso. È possibile utilizzare bufferedImage.getScaledInstance(..)

Answer 3

Come dice @Bozho, probabilmente si desidera utilizzare getScaledInstance.

Per capire come funziona grph.scale(2.0, 2.0) tuttavia, si potrebbe avere uno sguardo a questo codice:

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")); 
    } 
} 

Dato duke.png:

produce duke_double_size.png:

Answer 4

Sfortunatamente la prestazione di getScaled Instance() è molto povero se non problematico.

L'approccio alternativo consiste nel creare una nuova immagine bufferizzata e nel disegnare una versione ridimensionata dell'originale su quella nuova.

BufferedImage resized = new BufferedImage(newWidth, newHeight, original.getType()); 
Graphics2D g = resized.createGraphics(); 
g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, 
    RenderingHints.VALUE_INTERPOLATION_BILINEAR); 
g.drawImage(original, 0, 0, newWidth, newHeight, 0, 0, original.getWidth(), 
    original.getHeight(), null); 
g.dispose(); 

newWidth, newHeight indicano la nuova dimensione BufferedImage e devono essere calcolati correttamente. In caso di scalatura fattore:

int newWidth = new Double(original.getWidth() * widthFactor).intValue(); 
int newHeight = new Double(original.getHeight() * heightFactor).intValue(); 

EDIT: trovato l'articolo che illustra il problema di prestazioni: The Perils of Image.getScaledInstance()

Answer 5

Utilizzando imgscalr – Java Image Scaling Library:

BufferedImage image = 
    Scalr.resize(originalImage, Scalr.Method.BALANCED, newWidth, newHeight); 

Questo è abbastanza veloce per me.

Answer 6

Se non ti dispiace usare una libreria esterna, Thumbnailator può eseguire il ridimensionamento di BufferedImage s.

Thumbnailator si occuperà di gestire l'elaborazione Java 2D (come l'utilizzo Graphics2D e impostazione appropriata rendering hints) in modo che una semplice chiamata API fluente può essere utilizzato per ridimensionare immagini:

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

Sebbene Thumbnailator, come il suo nome implica, è orientato verso il restringimento delle immagini, farà un lavoro decente allargando anche le immagini, usando l'interpolazione bilineare nella sua implementazione predefinita del resettatore.

---

Disclaimer: io sono il manutentore della biblioteca Thumbnailator.

Answer 7

Per ridimensionare un'immagine, è necessario creare una nuova immagine e disegnarla. Un modo è utilizzare il metodo filter() di un AffineTransferOp, come suggerito here. Questo ti permette di scegliere la tecnica di interpolazione.

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; 
} 

Un altro modo è semplicemente di disegnare l'immagine originale nella nuova immagine, utilizzando un'operazione di ridimensionamento per eseguire il ridimensionamento. Questo metodo è molto simile, ma illustra anche come è possibile disegnare tutto ciò che si desidera nell'immagine finale. (Ho messo in una riga vuota in cui i due metodi iniziano a differire.)

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; 
}