java - jpg - como cambiar el tamaño de una imagen para imprimir

Cambiar el tamaño de la imagen almacenada

Question

Estoy tratando de cambiar el tamaño de una imagen en búfer. Puedo almacenarlo y mostrarme en un jframe sin problemas, pero parece que no puedo redimensionarlo. Cualquier consejo sobre cómo puedo cambiar esto para hacerlo funcionar y mostrar la imagen como un archivo 200 * 200 sería genial

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

Answer 1

Aquí hay un código que he usado para cambiar el tamaño de las imágenes en búfer, sin lujos, muy rápido:

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

Answer 2

Esta clase cambia el tamaño de un archivo y obtiene el nombre 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) );
}

}

Answer 3

Mira esto, ayuda:

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

Answer 4

Si todo lo que se requiere es cambiar el tamaño de una BufferedImage en el método de cambio de resize , entonces la biblioteca Thumbnailator puede hacerlo con bastante facilidad:

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

El código anterior cambiará el tamaño del img para que se ajuste a las dimensiones de newW y newH manteniendo la relación de aspecto de la imagen original.

Si no se requiere mantener la relación de aspecto y se requiere cambiar el tamaño exactamente a las dimensiones dadas, entonces se puede usar el método forceSize en lugar del método de size :

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

El uso del método Image.getScaledInstance no garantiza que la relación de aspecto de la imagen original se mantendrá para la imagen redimensionada y, además, en general es muy lenta.

Thumbnailator usa una técnica para cambiar progresivamente el tamaño de la imagen, que puede ser varias veces más rápido que Image.getScaledInstance mientras que logra una calidad de imagen que generalmente es comparable.

Descargo de responsabilidad: soy el mantenedor de esta biblioteca.

Answer 5

prueba la biblioteca imgscalr. Mejor lib que encontré, muy rápido, de buena calidad y fácil de usar

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

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

Licencia Apache 2

Answer 6

Respuesta actualizada

No puedo recordar por qué funcionó mi respuesta original, pero habiéndolo probado en un entorno separado, estoy de acuerdo, la respuesta original aceptada no funciona (por qué dije que sí, tampoco recuerdo). Esto, por otro lado, funcionó:

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