Ridimensionamento immagine bufferizzata

Sto cercando di ridimensionare un’immagine memorizzata. Sono in grado di memorizzarlo e presentarlo su un jframe senza problemi, ma non riesco a ridimensionarlo. Qualche suggerimento su come posso cambiarlo per farlo funzionare e mostrare l’immagine come un file 200 * 200 sarebbe fantastico

private void profPic(){ String path = factory.getString("bottle"); BufferedImage img = ImageIO.read(new File(path)); } public static BufferedImage resize(BufferedImage img, int newW, int newH) { int w = img.getWidth(); int h = img.getHeight(); BufferedImage dimg = new BufferedImage(newW, newH, img.getType()); Graphics2D g = dimg.createGraphics(); g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR); g.drawImage(img, 0, 0, newW, newH, 0, 0, w, h, null); g.dispose(); return dimg; } 

Risposta aggiornata

Non riesco a ricordare perché la mia risposta originale abbia funzionato, ma dopo averla testata in un ambiente separato, sono d’accordo, la risposta originale accettata non funziona (perché ho detto che non ricordo nemmeno). Questo, d’altra parte, ha funzionato:

 public static BufferedImage resize(BufferedImage img, int newW, int newH) { Image tmp = img.getScaledInstance(newW, newH, Image.SCALE_SMOOTH); BufferedImage dimg = new BufferedImage(newW, newH, BufferedImage.TYPE_INT_ARGB); Graphics2D g2d = dimg.createGraphics(); g2d.drawImage(tmp, 0, 0, null); g2d.dispose(); return dimg; } 

Se tutto ciò che è necessario è ridimensionare una BufferedImage nel metodo di resize , la libreria Thumbnailator può farlo abbastanza facilmente:

 public static BufferedImage resize(BufferedImage img, int newW, int newH) { return Thumbnails.of(img).size(newW, newH).asBufferedImage(); } 

Il codice sopra ridimensionerà l’ img per adattarsi alle dimensioni di newW e newH mantenendo le proporzioni dell’immagine originale.

Se non è necessario mantenere le proporzioni, è necessario ridimensionare esattamente le dimensioni indicate, quindi il metodo forceSize può essere utilizzato al posto del metodo di size :

 public static BufferedImage resize(BufferedImage img, int newW, int newH) { return Thumbnails.of(img).forceSize(newW, newH).asBufferedImage(); } 

L’utilizzo del metodo Image.getScaledInstance non garantisce che le proporzioni dell’immagine originale vengano mantenute per l’immagine ridimensionata e inoltre, in generale, è molto lenta.

Thumbnailator utilizza una tecnica per ridimensionare progressivamente l’immagine che può essere molto più veloce di Image.getScaledInstance pur ottenendo una qualità dell’immagine che è generalmente comparabile.

Disclaimer: sono il manutentore di questa libreria.

Questa class ridimensiona da un file e ottiene il nome del formato:

 import java.awt.Image; import java.awt.image.BufferedImage; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.util.Iterator; import javax.imageio.ImageIO; import javax.imageio.ImageReader; import javax.imageio.ImageWriter; import javax.imageio.stream.ImageInputStream; import org.apache.commons.io.IOUtils; public class ImageResizer { public static void main(String as[]) throws IOException{ File f = new File("C:/Users/samsungrob/Desktop/shuttle.jpg"); byte[] ba = resize(f, 600, 600); IOUtils.write(ba, new FileOutputStream( new File("C:/Users/samsungrob/Desktop/shuttle_resized.jpg") ) ); } public static byte[] resize(File file, int maxWidth, int maxHeight) throws IOException{ int scaledWidth = 0, scaledHeight = 0; BufferedImage img = ImageIO.read((ImageInputStream) file ); scaledWidth = maxWidth; scaledHeight = (int) (img.getHeight() * ( (double) scaledWidth / img.getWidth() )); if (scaledHeight> maxHeight) { scaledHeight = maxHeight; scaledWidth= (int) (img.getWidth() * ( (double) scaledHeight/ img.getHeight() )); if (scaledWidth > maxWidth) { scaledWidth = maxWidth; scaledHeight = maxHeight; } } Image resized = img.getScaledInstance( scaledWidth, scaledHeight, Image.SCALE_SMOOTH); BufferedImage buffered = new BufferedImage(scaledWidth, scaledHeight, Image.SCALE_REPLICATE); buffered.getGraphics().drawImage(resized, 0, 0 , null); String formatName = getFormatName( file ) ; ByteArrayOutputStream out = new ByteArrayOutputStream(); ImageIO.write(buffered, formatName, out); return out.toByteArray(); } private static String getFormatName(ImageInputStream iis) { try { // Find all image readers that recognize the image format Iterator iter = ImageIO.getImageReaders(iis); if (!iter.hasNext()) { // No readers found return null; } // Use the first reader ImageReader reader = (ImageReader)iter.next(); // Close stream iis.close(); // Return the format name return reader.getFormatName(); } catch (IOException e) { } return null; } private static String getFormatName(File file) throws IOException { return getFormatName( ImageIO.createImageInputStream(file) ); } private static String getFormatName(InputStream is) throws IOException { return getFormatName( ImageIO.createImageInputStream(is) ); } 

}

prova la libreria imgscalr. La migliore libreria ho trovato: molto veloce, di buona qualità e semplice da usare

 BufferedImage thumbnail = Scalr.resize(image, 150); 

http://www.thebuzzmedia.com/software/imgscalr-java-image-scaling-library/

Licenza Apache 2

Ecco un codice che ho usato per ridimensionare bufferedimages, senza fronzoli, piuttosto veloce:

 public static BufferedImage scale(BufferedImage src, int w, int h) { BufferedImage img = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB); int x, y; int ww = src.getWidth(); int hh = src.getHeight(); int[] ys = new int[h]; for (y = 0; y < h; y++) ys[y] = y * hh / h; for (x = 0; x < w; x++) { int newX = x * ww / w; for (y = 0; y < h; y++) { int col = src.getRGB(newX, ys[y]); img.setRGB(x, y, col); } } return img; } 

Dai un’occhiata, aiuta:

 BufferedImage bImage = ImageIO.read(new File(C:\image.jpg); BufferedImage thumbnail = Scalr.resize(bImage, Scalr.Method.SPEED, Scalr.Mode.FIT_TO_WIDTH, 750, 150, Scalr.OP_ANTIALIAS);