Kris

/*
This is re-constructed code I've written.  Although the methods have all been tested, I've
only pasted methods in here for things relevant to the discussion.  I haven't compiled
this exact version.
*/

public class ImageResizer {
    private static RenderingHints hints;
    static {
        hints = new RenderingHints(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
        hints.put(RenderingHints.KEY_COLOR_RENDERING,RenderingHints.VALUE_COLOR_RENDER_QUALITY);
        hints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);

        /*
         * this block is to silence the warning that we're not using JAI
         * native acceleration but are using the pure java implementation.
         */
        Properties p = new Properties(System.getProperties());
        p.put("com.sun.media.jai.disableMediaLib", "true");
        System.setProperties(p);
    }

    public static BufferedImage getScaledInstance(BufferedImage img, int maxWidth) {
        double scale = (double) maxWidth / img.getWidth();
        if ( scale > 1.0d ) {
            return getScaledUpGraphics(img, scale);
        } else if (scale > 0.5d && scale < 1.0d) {
            return getScaledDownByGraphics(img, scale);
        } else if (scale <= 0.5d) {
            return getScaledDownByJAI(img, scale);
        }
        // else scale == 1.0d; no change required.
        return img;
    }

    /**
     * See http://www.digitalsanctuary.com/tech-blog/java/how-to-resize-uploaded-images-using-java-better-way.html
     * This instance seems to produce quality images ONLY when you are
     * scaling down to something less than 50% of the original size.
     * @param img
     * @param scale
     * @return the scaled image
     */
    private static BufferedImage getScaledDownByJAI(BufferedImage img, double scale) {
        if(scale > 1.0d) {
            throw new RuntimeException("Can't scale according to " + scale + " : This method only scales down.");
        }
        PlanarImage originalImage = PlanarImage.wrapRenderedImage(img);
        // now resize the image
        ParameterBlock paramBlock = new ParameterBlock();
        paramBlock.addSource(originalImage); // The source image
        paramBlock.add(scale); // The xScale
        paramBlock.add(scale); // The yScale
        paramBlock.add(0.0); // The x translation
        paramBlock.add(0.0); // The y translation

        RenderedOp resizedImage = JAI.create("SubsampleAverage", paramBlock, hints);
        return resizedImage.getAsBufferedImage();
    }

    /**
     * This method produces high quality images when target scale is greater
     * than 50% of the original.
     * @param img
     * @param scale
     * @return the scaled image
     */
    private static BufferedImage getScaledDownByGraphics(BufferedImage img, double scale) {
        final float scaleFactor = 0.8f;

        BufferedImage ret = (BufferedImage)img;
        int w = img.getWidth();
        int h = img.getHeight();

        int targetWidth = (int)(img.getWidth() * scale);
        int targetHeight = (int)(img.getHeight() * scale);

        int loopCount = 0;
        int maxLoopCount = 20;
        BufferedImage tmp;
        do {
            if (w > targetWidth) {
                w *= scaleFactor;
                if (w < targetWidth) {
                    w = targetWidth;
                }
            }
            if (h > targetHeight) {
                h *= scaleFactor;
                if (h < targetHeight) {
                    h = targetHeight;
                }
            }
            tmp = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
            Graphics2D g2 = tmp.createGraphics();

            g2.addRenderingHints(hints);
            g2.drawImage(ret, 0, 0, w, h, null);
            g2.dispose();

            ret = tmp;
            if(++loopCount > maxLoopCount) {
                throw new RuntimeException("Hit maximum loop count " + maxLoopCount);
            }
        } while (w != targetWidth || h != targetHeight);
        return ret;
    }

    /**
     * When you scale up, there's nothing complicated that will give you a better image.
     * Just scale it up on a basic
     * @param orig
     * @param scale
     * @return
     */
    private static BufferedImage getScaledUpGraphics(final BufferedImage orig, double scale) {
        int scaledWidth  = (int)(orig.getWidth()  * scale);
        int scaledHeight = (int)(orig.getHeight() * scale);
        BufferedImage scaledBI = new BufferedImage(scaledWidth, scaledHeight, BufferedImage.TYPE_INT_RGB);
        Graphics2D g = scaledBI.createGraphics();
        g.setRenderingHints(hints);
        g.drawImage(orig, 0, 0, scaledWidth, scaledHeight, null);
        g.dispose();
        return scaledBI;
    }
}