Bufferedimage resize

j'essaie de redimensionner un tampon. Je suis en mesure de stocker et de l'afficher sur une jframe pas de problèmes, mais je n'arrive pas à redimensionner. Des conseils sur comment je peux changer ça pour le faire fonctionner et montrer l'image de 200*200 fichier serait génial

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;  
}  
33
demandé sur Grant Miller 2012-02-23 20:47:30

6 réponses

réponse mise à jour

je ne me souviens pas pourquoi ma réponse originale à cette question a fonctionné mais après l'avoir testé dans un environnement séparé, je suis d'accord, la réponse originale acceptée ne fonctionne pas (pourquoi j'ai dit qu'il a fait je ne me souviens pas non plus). Cela, d'un autre côté, a fonctionné:

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;
}  
44
répondu Ocracoke 2017-05-23 12:17:44

Si tout ce qui est nécessaire est de redimensionner une BufferedImage dans le resize méthode, puis le Thumbnailator bibliothèque peuvent le faire assez facilement:

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

Le code ci-dessus va redimensionner l' img pour l'adapter aux dimensions de newW et newH tout en maintenant le format de l'image originale.

Si maintenir le ratio d'aspect n'est pas nécessaire et le redimensionnement exactement les dimensions, le forceSize méthode peut être utilisée dans la place de l' size méthode:

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

Image.getScaledInstance la méthode ne garantit pas que le rapport d'aspect de l'image originale sera maintenu pour l'image redimensionnée, et de plus, il est en général très lent.

Thumbnailator utilise une technique pour redimensionner progressivement l'image qui peut être plusieurs fois plus rapide que Image.getScaledInstance tout en obtenant une qualité d'image qui est généralement comparable.

avertissement: je suis le responsable de cette bibliothèque.

18
répondu coobird 2012-03-14 16:02:03

cette classe redimensionne à partir d'un fichier et obtient le nom de format:

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

}

3
répondu Frizz1977 2015-09-02 08:02:52

essayez la bibliothèque imgscalr. Meilleure lib j'ai trouvé-très rapide, de bonne qualité et simple à utiliser

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

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

Licence Apache 2

2
répondu Alexander Pfeif 2013-12-06 09:20:34

Voici un code que j'ai utilisé pour redimensionner bufferedimages, pas de fioritures, assez rapide:

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;
}
1
répondu rlbaker 2017-06-27 14:33:50

Check this out, il permet de:

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);
0
répondu Kiran_Pawar 2014-09-22 12:12:30