I need to resize images when loading in Java / Struts. How to do it?

Question

We are creating an application that handles image loading. I want users to be able to upload an image with a given size, say 128x128, and then the server will automatically generate other sizes based on such as 64x64, 57x57 and 25x25.

Are there any libraries that can help me?

Edit: I should note that resizing should only happen on boot. When new sizes of images are displayed in the browser, they should be pulled out of cached copies - do not repeat the resizing. In other words, different sizes should be generated only once, and not every time images are requested.

Answer 1

I used the ImageIO and ImageInfo libraries for similar functions. So far they are pretty good.

http://java.sun.com/javase/6/docs/api/javax/imageio/ImageIO.html

http://kickjava.com/src/imageinfo/ImageInfo.java.htm

I remember some performance issues with native java libraries when retrieving image sizes and therefore for using ImageInfo.

Hope this helps.

Answer 2

This may be helpful. AFAIK, there are many ways to do this with different speed / image quality.

Answer 3

, imgscalr (Apache 2) - , .

Java ( ), , , , ... 200 , , 50 , 25 "", -, .

, , , , , , , 1- API, " " .

API :

BufferedImage scaledImg = Scalr.resize(img, 150);

, , , QUALITY, Chris Campbell ( Java2D) ConvolveOp , .

:

BufferedImage img = ImageIO.read(...); // load image
BufferedImage scaledImg = Scalr.resize(img, Method.QUALITY, 
                                       50, Scalr.OP_ANTIALIAS);

w/h, , , , , , , ( , ).

- ConvolveOps, , , , , , , , , PIA - , , , , , .

, , Scalr BufferedImageOp, ( 6- -old JDK, ).

" " , , , , , - , Java2D (, , GIF , , crap-imgscalr, ) , " ".

, .

Answer 4

Swing:

/**
 * Resizes an image using a Graphics2D object backed by a BufferedImage.
 * @param srcImg - source image to scale
 * @param w - desired width
 * @param h - desired height
 * @return - the new resized image
 */
private Image getScaledImage(Image srcImg, int w, int h){
    BufferedImage resizedImg = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
    Graphics2D g2 = resizedImg.createGraphics();
    g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
    g2.drawImage(srcImg, 0, 0, w, h, null);
    g2.dispose();
    return resizedImg;
}

Answer 5

Useful function from one of our java portal pages (encoded from an example from several forums, I do not pretend to be an author)

Hope this help
Guillaume Patry

/**
 * Convenience method that returns a scaled instance of the
 * provided {@code BufferedImage}.
 *
 * @param img the original image to be scaled
 * @param targetWidth the desired width of the scaled instance,
 *    in pixels
 * @param targetHeight the desired height of the scaled instance,
 *    in pixels
 * @param hint one of the rendering hints that corresponds to
 *    {@code RenderingHints.KEY_INTERPOLATION} (e.g.
 *    {@code RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR},
 *    {@code RenderingHints.VALUE_INTERPOLATION_BILINEAR},
 *    {@code RenderingHints.VALUE_INTERPOLATION_BICUBIC})
 * @param higherQuality if true, this method will use a multi-step
 *    scaling technique that provides higher quality than the usual
 *    one-step technique (only useful in downscaling cases, where
 *    {@code targetWidth} or {@code targetHeight} is
 *    smaller than the original dimensions, and generally only when
 *    the {@code BILINEAR} hint is specified)
 * @return a scaled version of the original {@code BufferedImage}
 */
 public BufferedImage getScaledInstance(
            BufferedImage img,
            int targetWidth,
            int targetHeight,
            Object hint,
            boolean higherQuality) {
BufferedImage ret = (BufferedImage) img;
int w, h;
if (higherQuality) {
    // Use multi-step technique: start with original size, then
    // scale down in multiple passes with drawImage()
    // until the target size is reached
    w = img.getWidth();
    h = img.getHeight();
} else {  
    // Use one-step technique: scale directly from original
    // size to target size with a single drawImage() call
    w = targetWidth;
    h = targetHeight;
}

do {
   if (higherQuality) {
      if (w > targetWidth) {
         w /= 2;
         if (w < targetWidth) {
            w = targetWidth;
         }
      } else {
         w = targetWidth;
      }
      if (h > targetHeight) {
         h /= 2;
         if (h < targetHeight) {
        h = targetHeight;
         }
      } else {
         h = targetHeight;
      }
   }
   BufferedImage tmp = null;
   if (img.getType() == 0) {
      tmp = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
   } else {
      tmp = new BufferedImage(w, h, img.getType());
   }
   Graphics2D g2 = tmp.createGraphics();
   g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION, hint);
   g2.drawImage(ret, 0, 0, w, h, null);
   g2.dispose();
   ret = tmp;
} while (w != targetWidth || h != targetHeight);
return ret;

}