tipo - como cambiar el tamaño de una etiqueta en java

¿Cómo puedo cambiar el tamaño de una imagen usando Java?

Question

Necesito cambiar el tamaño de los archivos PNG, JPEG y GIF. ¿Cómo puedo hacer esto usando Java?

Answer 1

Después de cargar la imagen puede intentar:

BufferedImage createResizedCopy(Image originalImage, 
            int scaledWidth, int scaledHeight, 
            boolean preserveAlpha)
    {
        System.out.println("resizing...");
        int imageType = preserveAlpha ? BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;
        BufferedImage scaledBI = new BufferedImage(scaledWidth, scaledHeight, imageType);
        Graphics2D g = scaledBI.createGraphics();
        if (preserveAlpha) {
            g.setComposite(AlphaComposite.Src);
        }
        g.drawImage(originalImage, 0, 0, scaledWidth, scaledHeight, null); 
        g.dispose();
        return scaledBI;
    }

Answer 2

FWIW Acabo de lanzar (Apache 2, alojado en GitHub) una biblioteca de escala de imágenes simple para Java llamada imgscalr (disponible en Maven central ).

La biblioteca implementa algunos enfoques diferentes para escalar imágenes (incluido el enfoque incremental de Chris Campbell con algunas mejoras menores) y seleccionará el enfoque más óptimo para usted si se lo pide, o le brindará el aspecto más rápido o mejor (si pregunta por eso).

El uso es completamente simple, solo un montón de métodos estáticos. El caso de uso más simple es:

BufferedImage scaledImage = Scalr.resize(myImage, 200);

Todas las operaciones mantienen las proporciones originales de la imagen, por lo que en este caso le está pidiendo a imgscalr que cambie el tamaño de su imagen dentro de un límite de 200 píxeles de ancho y 200 píxeles de alto y de forma predeterminada seleccionará el mejor aspecto y el más rápido para eso ya que no fue ''t especificado.

Me di cuenta desde el principio que esto se parece a la autopromoción (lo es), pero pasé mi gran parte del tiempo buscando en Google este mismo tema y seguí buscando diferentes resultados / enfoques / pensamientos / sugerencias y decidí sentarme y escribir un Implementación simple que abarcaría el 80-85% de casos de uso donde tiene una imagen y probablemente quiera una miniatura para ella, ya sea lo más rápido posible o lo más guapa posible (para aquellos que lo han intentado, lo notará haciendo una Graphics.drawImage incluso con interpolación BICUBIC a una imagen lo suficientemente pequeña, todavía parece basura).

Answer 3

He desarrollado una solución con las clases disponibles gratuitamente (AnimatedGifEncoder, GifDecoder y LWZEncoder) disponibles para manejar GIF Animation.
Puede descargar el jar jgifcode y ejecutar la clase GifImageUtil. Enlace: http://www.jgifcode.com

Answer 4

Image Magick ha sido mencionado. Hay un proyecto de interfaz JNI llamado JMagick. No es un proyecto particularmente estable (y se ha sabido que Image Magick en sí mismo cambia mucho e incluso rompe la compatibilidad). Dicho esto, hemos tenido una buena experiencia al utilizar JMagick y una versión compatible de Image Magick en un entorno de producción para realizar escalas a un alto rendimiento y baja tasa de latencia. La velocidad fue sustancialmente mejor que con una biblioteca gráfica de Java que probamos anteriormente.

http://www.jmagick.org/index.html

Answer 5

La API de Java no proporciona una característica de escalado estándar para las imágenes y degrada la calidad de la imagen.

Debido a esto, traté de usar cvResize desde JavaCV, pero parece causar problemas.

Encontré una buena biblioteca para escala de imágenes: simplemente agregue la dependencia para "java-image-scaling" en su pom.xml.

<dependency>
    <groupId>com.mortennobel</groupId>
    <artifactId>java-image-scaling</artifactId>
    <version>0.8.6</version>
</dependency>

En el repositorio de maven obtendrá la versión más reciente para esto.

Ex. En tu programa java

ResampleOp resamOp = new ResampleOp(50, 40);
BufferedImage modifiedImage = resamOp.filter(originalBufferedImage, null);

Answer 6

No necesitas una biblioteca para hacer esto. Puedes hacerlo con Java.

Chris Campbell tiene una reseña excelente y detallada sobre la escala de imágenes - ver este artículo .

Chet Haase y Romain Guy también tienen una descripción detallada y muy informativa de la escala de la imagen en su libro, Filthy Rich Clients .

Answer 7

Podría intentar usar el GraphicsMagick Image Processing System con im4java como una interfaz de línea de im4java para Java.

Hay muchas ventajas de GraphicsMagick, pero una para todos:

• GM se utiliza para procesar miles de millones de archivos en los sitios de fotos más grandes del mundo (por ejemplo, Flickr y Etsy).

Answer 8

Puede usar Marvin (framework de procesamiento de imágenes puro de Java) para este tipo de operación: http://marvinproject.sourceforge.net

Plug-in de escala: http://marvinproject.sourceforge.net/en/plugins/scale.html

Answer 9

Resulta que escribir un escalador de rendimiento no es trivial. Lo hice una vez para un proyecto de código abierto: ImageScaler .

En principio, ''java.awt.Image # getScaledInstance (int, int, int)'' haría el trabajo también, pero hay un desagradable error con esto - consulte mi enlace para más detalles.

Answer 10

Si no quieres importar imgscalr como @Riyad Kalla, la respuesta anterior que he probado también funciona bien, puedes hacer esto tomado de Peter Walser y responder a Peter Walser sobre otro problema:

 /**
     * utility method to get an icon from the resources of this class
     * @param name the name of the icon
     * @return the icon, or null if the icon wasn''t found.
     */
    public Icon getIcon(String name) {
        Icon icon = null;
        URL url = null;
        ImageIcon imgicon = null;
        BufferedImage scaledImage = null;
        try {
            url = getClass().getResource(name);

            icon = new ImageIcon(url);
            if (icon == null) {
                System.out.println("Couldn''t find " + url);
            }

            BufferedImage bi = new BufferedImage(
                    icon.getIconWidth(),
                    icon.getIconHeight(),
                    BufferedImage.TYPE_INT_RGB);
            Graphics g = bi.createGraphics();
            // paint the Icon to the BufferedImage.
            icon.paintIcon(null, g, 0,0);
            g.dispose();

            bi = resizeImage(bi,30,30);
            scaledImage = bi;// or replace with this line Scalr.resize(bi, 30,30);
            imgicon = new ImageIcon(scaledImage);

        } catch (Exception e) {
            System.out.println("Couldn''t find " + getClass().getName() + "/" + name);
            e.printStackTrace();
        }
        return imgicon;
    }

 public static BufferedImage resizeImage (BufferedImage image, int areaWidth, int areaHeight) {
        float scaleX = (float) areaWidth / image.getWidth();
        float scaleY = (float) areaHeight / image.getHeight();
        float scale = Math.min(scaleX, scaleY);
        int w = Math.round(image.getWidth() * scale);
        int h = Math.round(image.getHeight() * scale);

        int type = image.getTransparency() == Transparency.OPAQUE ? BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB;

        boolean scaleDown = scale < 1;

        if (scaleDown) {
            // multi-pass bilinear div 2
            int currentW = image.getWidth();
            int currentH = image.getHeight();
            BufferedImage resized = image;
            while (currentW > w || currentH > h) {
                currentW = Math.max(w, currentW / 2);
                currentH = Math.max(h, currentH / 2);

                BufferedImage temp = new BufferedImage(currentW, currentH, type);
                Graphics2D g2 = temp.createGraphics();
                g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
                g2.drawImage(resized, 0, 0, currentW, currentH, null);
                g2.dispose();
                resized = temp;
            }
            return resized;
        } else {
            Object hint = scale > 2 ? RenderingHints.VALUE_INTERPOLATION_BICUBIC : RenderingHints.VALUE_INTERPOLATION_BILINEAR;

            BufferedImage resized = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
            Graphics2D g2 = resized.createGraphics();
            g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, hint);
            g2.drawImage(image, 0, 0, w, h, null);
            g2.dispose();
            return resized;
        }
    }

Answer 11

Si se trata de imágenes de gran tamaño o desea un buen resultado, no es una tarea trivial en Java. Simplemente hacerlo a través de una operación de cambio de escala a través de Graphics2D no creará una miniatura de alta calidad. Puedes hacerlo utilizando JAI, pero requiere más trabajo de lo que imaginas para obtener algo que se vea bien y JAI tiene la mala costumbre de explotar nuestra JVM con errores OutOfMemory.

Sugiero usar ImageMagick como un ejecutable externo si puede salirse con la suya. Es fácil de usar y hace bien el trabajo para que no sea necesario.

Answer 12

Si, teniendo imagemagick instalado en su maschine es una opción, recomiendo im4java . Es una capa de abstracción muy delgada sobre la interfaz de línea de comando, pero cumple su función muy bien.

Answer 13

Simplemente use la respuesta de Burkhard, pero agregue esta línea después de crear los gráficos:

    g.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);

También podría establecer el valor en BICUBIC, producirá una imagen de mejor calidad pero es una operación más costosa. Hay otras sugerencias de renderización que puede establecer pero he encontrado que la interpolación produce el efecto más notable. Tenga en cuenta que si quiere acercarse mucho, es probable que el código Java sea muy lento. Encuentro que las imágenes más grandes comienzan a producir un retraso de alrededor del 300% de zoom, incluso con todas las pistas de renderización configuradas para optimizar la velocidad sobre la calidad.

Answer 14

puede usar el siguiente producto popular: thumbnailator

Answer 15

Java Advanced Imaging ahora es de código abierto y proporciona las operaciones que necesita.

Answer 16

Thumbnailator es una biblioteca de redimensionamiento de imagen de código abierto para Java con una interfaz fluida, distribuida bajo la licencia MIT.

Escribí esta biblioteca porque hacer miniaturas de alta calidad en Java puede ser sorprendentemente difícil, y el código resultante podría ser bastante complicado. Con Thumbnailator, es posible expresar tareas bastante complicadas usando una simple API fluida.

Un simple ejemplo

Para un ejemplo simple, tomar una imagen y cambiar su tamaño a 100 x 100 (preservando la relación de aspecto de la imagen original) y guardarla en un archivo se puede lograr en una sola declaración:

Thumbnails.of("path/to/image")
    .size(100, 100)
    .toFile("path/to/thumbnail");

Un ejemplo avanzado

Realizar tareas complejas de redimensionamiento se simplifica con la fluida interfaz de Thumbnailator.

Supongamos que queremos hacer lo siguiente:

1. tomar las imágenes en un directorio y,
2. cambiar el tamaño de ellos a 100 x 100, con la relación de aspecto de la imagen original,
3. guárdelos todos en archivos JPEG con una configuración de calidad de 0.85 ,
4. donde los nombres de los archivos se toman del original con thumbnail. Anexado al comienzo

Traducido al Thumbnailator, podríamos realizar lo anterior con lo siguiente:

Thumbnails.of(new File("path/to/directory").listFiles())
    .size(100, 100)
    .outputFormat("JPEG")
    .outputQuality(0.85)
    .toFiles(Rename.PREFIX_DOT_THUMBNAIL);

Una nota sobre la calidad de imagen y la velocidad

Esta biblioteca también utiliza el método progresivo de escalado bilineal resaltado en Filthy Rich Clients por Chet Haase y Romain Guy para generar miniaturas de alta calidad a la vez que garantiza un rendimiento de tiempo de ejecución aceptable.