ruta - ¿Cómo se crea una imagen en miniatura de un JPEG en Java?
obtener la ruta de una imagen en java (12)
¡He usado Thumbnailator! Solucionó mi problema con dos líneas de código.
¿Alguien puede ayudarme con algún código para crear una miniatura para un JPEG en Java?
Soy nuevo en esto, por lo que una explicación paso a paso sería apreciada.
Como podría haber descubierto "fácil" y "buen resultado" son dos cosas muy diferentes. He encapsulado estos dos requisitos en una biblioteca de escalado de imágenes Java muy simple (licencia Apache 2) que hace todo lo correcto para usted.
El código de ejemplo para crear una miniatura se ve así:
BufferedImage img = ImageIO.read(...); // load image
BufferedImage scaledImg = Scalr.resize(img, 150);
Se respetan las proporciones de la imagen, la biblioteca adivina el método que debe usar en función de la cantidad de cambios en la imagen debido a la escala (MÁS RÁPIDO, EQUILIBRADO o CALIDAD) y los tipos de imágenes mejor compatibles con Java2D siempre se usan para hacer la escala para evitar el problema de los resultados "negros" o resultados realmente terribles (por ejemplo, imágenes GIF excesivamente titiladas).
Además, si desea obligarlo a generar la miniatura más atractiva posible en Java, la llamada a la API se vería así:
BufferedImage img = ImageIO.read(...); // load image
BufferedImage scaledImg = Scalr.resize(img, Method.QUALITY,
150, 100, Scalr.OP_ANTIALIAS);
La biblioteca no solo utilizará la escala incremental recomendada por Java2D para que pueda obtener el mejor resultado posible, sino que también aplicará un efecto antialiasing opcional a la miniatura (ConvolveOp con un kernel muy afinado) para suavizar ligeramente la Transiciones entre valores de píxel para que la miniatura se vea más uniforme y nítida o amapola, como podría haber visto al pasar de imágenes muy grandes a pequeñas.
Puede leer todos los comentarios en la biblioteca (el código en sí mismo es muy complicado) para ver los diferentes errores de JDK que se han solucionado o las optimizaciones que se realizan para mejorar el rendimiento o el uso de la memoria. Pasé MUCHO tiempo ajustando esta implementación y he tenido muchos buenos comentarios de personas que lo implementan en aplicaciones web y otros proyectos de Java.
Esta es una forma simple de crear una miniatura de 100 X 100 sin ningún estiramiento o sesgo en la imagen.
private void saveScaledImage(String filePath,String outputFile){
try {
BufferedImage sourceImage = ImageIO.read(new File(filePath));
int width = sourceImage.getWidth();
int height = sourceImage.getHeight();
if(width>height){
float extraSize= height-100;
float percentHight = (extraSize/height)*100;
float percentWidth = width - ((width/100)*percentHight);
BufferedImage img = new BufferedImage((int)percentWidth, 100, BufferedImage.TYPE_INT_RGB);
Image scaledImage = sourceImage.getScaledInstance((int)percentWidth, 100, Image.SCALE_SMOOTH);
img.createGraphics().drawImage(scaledImage, 0, 0, null);
BufferedImage img2 = new BufferedImage(100, 100 ,BufferedImage.TYPE_INT_RGB);
img2 = img.getSubimage((int)((percentWidth-100)/2), 0, 100, 100);
ImageIO.write(img2, "jpg", new File(outputFile));
}else{
float extraSize= width-100;
float percentWidth = (extraSize/width)*100;
float percentHight = height - ((height/100)*percentWidth);
BufferedImage img = new BufferedImage(100, (int)percentHight, BufferedImage.TYPE_INT_RGB);
Image scaledImage = sourceImage.getScaledInstance(100,(int)percentHight, Image.SCALE_SMOOTH);
img.createGraphics().drawImage(scaledImage, 0, 0, null);
BufferedImage img2 = new BufferedImage(100, 100 ,BufferedImage.TYPE_INT_RGB);
img2 = img.getSubimage(0, (int)((percentHight-100)/2), 100, 100);
ImageIO.write(img2, "jpg", new File(outputFile));
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
Hace años que escribí clase util con métodos estáticos usando JAI. Java Advanced Imaging API es la API más confiable en Java para manejar imágenes. La interpolación de vectores es lo más parecido a Photoshop en el mundo de Java. Aqui esta uno de ellos:
public static ByteArrayOutputStream resize(InputStream inputStream , int IMG_WIDTH,
int IMG_HEIGHT) throws Exception {
BufferedImage originalImage = ImageIO.read(inputStream);
int type = originalImage.getType() == 0 ? BufferedImage.TYPE_INT_ARGB
: originalImage.getType();
BufferedImage resizedImage = new BufferedImage(IMG_WIDTH, IMG_HEIGHT,
type);
{
Graphics2D g = resizedImage.createGraphics();
g.drawImage(originalImage, 0, 0, IMG_WIDTH, IMG_HEIGHT, null);
g.dispose();
g.setComposite(AlphaComposite.Src);
g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
RenderingHints.VALUE_INTERPOLATION_BILINEAR);
g.setRenderingHint(RenderingHints.KEY_RENDERING,
RenderingHints.VALUE_RENDER_QUALITY);
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
}
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ImageIO.write(resizedImage, "png", bos);
return bos;
}
Hay muchos marcos de procesamiento de imágenes disponibles que puedes hacer con solo unas pocas líneas. El siguiente ejemplo genera las miniaturas en diferentes resoluciones (dado el ancho como referencia) usando Marvin Framework . Las tres miniaturas se generaron en 92 ms .
entrada:
salida:
import static marvin.MarvinPluginCollection.*;
MarvinImage image = MarvinImageIO.loadImage("./res/input.jpg");
MarvinImage scaledImage = new MarvinImage(1,1);
scale(image, scaledImage, 250);
MarvinImageIO.saveImage(scaledImage, "./res/output_x250.jpg");
scale(image, scaledImage, 150);
MarvinImageIO.saveImage(scaledImage, "./res/output_x150.jpg");
scale(image, scaledImage, 50);
MarvinImageIO.saveImage(scaledImage, "./res/output_x50.jpg");
He creado una aplicación llamada fotovault (sourceforge.net) que puede cargar imágenes y crear miniaturas en java usando imagej apis.
Por favor, lea mi blog a continuación
http://www.gingercart.com/Home/java-snippets/create-image-thumbnail-in-java-using-imagej-api
He revisado un blog según el cual tienes las siguientes opciones:
- Para archivos RGB simples use ImageScalr. La clase ImageIO se usa para leer archivos e ImageScalr para crear miniaturas
- Para admitir RGB + CYMK, utilice la API ImageIO y JAI (Java Advanced Imaging) para leer archivos e ImageScalr para crear miniaturas.
- En caso de que no sepa qué formatos de archivo, modo de color va a tratar, la opción más segura es usar ImageMagick.
Aquí hay un link que da una respuesta completa con fragmentos de código.
La biblioteca JMagick (y la implementación de ImageMagick en Java) tendrá lo que necesita.
Manera simple de crear una miniatura sin estirar o una biblioteca. Funciona con transparencia en pngs, también.
public File createThumbnail(String imageUrl, String targetPath) {
final int imageSize = 100;
File thumbnail = new File(targetPath);
try {
thumbnail.getParentFile().mkdirs();
thumbnail.createNewFile();
BufferedImage sourceImage = ImageIO.read(new File(imageUrl));
float width = sourceImage.getWidth();
float height = sourceImage.getHeight();
BufferedImage img2;
if (width > height) {
float scaledWidth = (width / height) * (float) imageSize;
float scaledHeight = imageSize;
BufferedImage img = new BufferedImage((int) scaledWidth, (int) scaledHeight, sourceImage.getType());
Image scaledImage = sourceImage.getScaledInstance((int) scaledWidth, (int) scaledHeight, Image.SCALE_SMOOTH);
img.createGraphics().drawImage(scaledImage, 0, 0, null);
int offset = (int) ((scaledWidth - scaledHeight) / 2f);
img2 = img.getSubimage(offset, 0, imageSize, imageSize);
}
else if (width < height) {
float scaledWidth = imageSize;
float scaledHeight = (height / width) * (float) imageSize;
BufferedImage img = new BufferedImage((int) scaledWidth, (int) scaledHeight, sourceImage.getType());
Image scaledImage = sourceImage.getScaledInstance((int) scaledWidth, (int) scaledHeight, Image.SCALE_SMOOTH);
img.createGraphics().drawImage(scaledImage, 0, 0, null);
int offset = (int) ((scaledHeight - scaledWidth) / 2f);
img2 = img.getSubimage(0, offset, imageSize, imageSize);
}
else {
img2 = new BufferedImage(imageSize, imageSize, sourceImage.getType());
Image scaledImage = sourceImage.getScaledInstance(imageSize, imageSize, Image.SCALE_SMOOTH);
img2.createGraphics().drawImage(scaledImage, 0, 0, null);
}
ImageIO.write(img2, "png", thumbnail);
}
catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return thumbnail;
}
Sé que esta es una publicación bastante antigua. He estado buscando una solución para generar la miniatura, así que termino usando esto
Thumbnails.of(originalImage).scale(0.25).asBufferedImage();
Si está utilizando para dispositivos móviles sugeriría establecer la escala en 0.45
Thumbnails.of(originalImage).scale(0.45).asBufferedImage();
https://github.com/coobird/thumbnailator
Esto es ciertamente mucho más rápido usando Graphics2D ya que he probado las dos opciones.
el código Java anterior (con los métodos scale / getCompatibleImage) funcionó muy bien para mí, pero cuando implementé en un servidor, dejó de funcionar, porque el servidor no tenía pantalla asociada; cualquier otra persona con este problema puede solucionarlo mediante el uso de : BufferedImage bi = new BufferedImage (w, h, BufferedImage.TYPE_INT_RGB);
en lugar de BufferedImage bi = getCompatibleImage (w, h);
y eliminar el método getCompatibleImage
(Nota posterior: resulta que funciona muy bien para la mayoría de las imágenes, pero obtuve un montón del departamento de marketing de mi empresa que son imágenes JPEG de 32 bits de profundidad de color, y la biblioteca arroja una excepción de formato de imagen no admitida para todos :( - - imagemagick / jmagick están empezando a verse más atractivos)
Image img = ImageIO.read(new File("test.jpg")).getScaledInstance(100, 100, BufferedImage.SCALE_SMOOTH);
Esto creará una miniatura de 100x100 píxeles como un objeto de Imagen. Si desea volver a escribirlo en el disco, simplemente convierta el código a este:
BufferedImage img = new BufferedImage(100, 100, BufferedImage.TYPE_INT_RGB);
img.createGraphics().drawImage(ImageIO.read(new File("test.jpg")).getScaledInstance(100, 100, Image.SCALE_SMOOTH),0,0,null);
ImageIO.write(img, "jpg", new File("test_thumb.jpg"));
Además, si le preocupan los problemas de velocidad (el método descrito anteriormente es bastante lento si desea escalar muchas imágenes), use estos métodos y la siguiente declaración:
private BufferedImage scale(BufferedImage source,double ratio) {
int w = (int) (source.getWidth() * ratio);
int h = (int) (source.getHeight() * ratio);
BufferedImage bi = getCompatibleImage(w, h);
Graphics2D g2d = bi.createGraphics();
double xScale = (double) w / source.getWidth();
double yScale = (double) h / source.getHeight();
AffineTransform at = AffineTransform.getScaleInstance(xScale,yScale);
g2d.drawRenderedImage(source, at);
g2d.dispose();
return bi;
}
private BufferedImage getCompatibleImage(int w, int h) {
GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice gd = ge.getDefaultScreenDevice();
GraphicsConfiguration gc = gd.getDefaultConfiguration();
BufferedImage image = gc.createCompatibleImage(w, h);
return image;
}
Y luego llama:
BufferedImage scaled = scale(img,0.5);
donde 0.5 es la proporción de escala e img es una Imagen Buffered que contiene la imagen de tamaño normal.