How can I make my thumbnails softer & smoother?

Question

Hi, I am trying to create thumbnails from my digital camera. I have been comparing JMagick to the java2d api. My needs are simple - resize jpegs. I am finding indistinguishable image quality between the two when I resize except in the case of thumbnails. Those I am getting from the java2d package are looking sharp & brittle. The ones from Jmagick are soft & smooth. Can anyone please let me know how I can get softer & smoother thumbnails from Java2d? Here is my test that compares JMagick & java2d - notice there are several different possible ways I am saving using Java2d (JAI, AffineTransform, and Graphics2d). I am finding the best results (quickest) using AffineTransform. The Graphics2d approach below is of noticably worse quality. I'm new to this so any help is appreciated.
Craig
What it does: I am using this to take 1600 x 1200 images & create a copy, a 1024x768 image, and a 150x112 thumbnail.
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.awt.image.AffineTransformOp;
import java.awt.geom.AffineTransform;
import java.awt.image.renderable.ParameterBlock;
import java.io.*;
import javax.imageio.ImageIO;
import javax.imageio.ImageWriter;
import javax.imageio.IIOImage;
import javax.imageio.spi.ImageWriterSpi;
import javax.imageio.spi.IIORegistry;
import javax.media.jai.Interpolation;
import javax.media.jai.InterpolationBicubic;
import javax.media.jai.PlanarImage;
import javax.media.jai.JAI;
import java.util.*;
import magick.ImageInfo;
import magick.MagickException;
import magick.MagickImage;
import com.sun.image.codec.jpeg.*;
import com.sun.media.jai.codec.*;
* @version      1.0
* @author          creichenbach
public class JmagickVsJava2d
     private     static     int          MAX_THUMBSIZE           = 150;
     private     static     int          MAX_IMAGESIZE          = 1024;
     static     final      String          APPENDAGE_THUMB          = "_tn";
     static     final      String          APPENDAGE_MED_COPY      = "_MediumCopy";
     static     final      String          APPENDAGE_COPY           = "_Copy";
     //               THUMBNAILS                     //
     double scaleImageJava2d( List imgs, int maxSize, String appendage ) throws Exception
          long start = System.currentTimeMillis();
          int size = imgs.size();
          for ( int i=0;i<size;i++ )
               File f = (File) imgs.get( i );
               String imgPath = f.getAbsolutePath();
               String copyPath = imgPath.substring(0, imgPath.length()-4) + "Java2d"+appendage+".jpg";
               File infile = new File( imgPath );
               FileInputStream fis = new FileInputStream( infile );
               com.sun.image.codec.jpeg.JPEGImageDecoder decoder = com.sun.image.codec.jpeg.JPEGCodec.createJPEGDecoder(fis);
               BufferedImage im = decoder.decodeAsBufferedImage();
               fis.close();
               int width = im.getWidth();
               int height = im.getHeight();
               double scale = getScale( width, height, maxSize );
               //uncomment to use Affine Transform
               scaleAndSaveWithAffineTransform( scale, im, copyPath );
               //uncomment to use JAI
               //scaleAndSaveWithJAI( scale, im, copyPath );
               //uncomment to use Graphics2d
               //scaleAndSaveWithGraphics2d( im, width, height, maxSize, copyPath );
          long stop = System.currentTimeMillis();
          return getElapsedTime( start, stop );          
     double scaleImageJmagick( List imgs, int maxSize, String appendage ) throws IOException
          try
               long start = System.currentTimeMillis();
               int size = imgs.size();
               for ( int i=0;i<size;i++ )
                    File f = (File) imgs.get( i );
                    String imgPath = f.getAbsolutePath();
                    String copyPath = imgPath.substring(0, imgPath.length()-4) + "Jmagick"+appendage+".jpg";
                    ImageInfo imgInfo = new ImageInfo( imgPath );
                    MagickImage image = new MagickImage( imgInfo );
                    int width = (int) image.getDimension().getWidth();
                    int height = (int) image.getDimension().getHeight();
                    int[] dim = getImageDimensions( width, height, maxSize );
                    MagickImage thumbnail = image.scaleImage( dim[ 0 ], dim[ 1 ] );
                    thumbnail.setFileName( copyPath );
                    thumbnail.writeImage( imgInfo );
               long stop = System.currentTimeMillis();
               return getElapsedTime( start, stop );     
          catch (MagickException e)
               throw new IOException( "MagickException. Failure creating thumbnails." );
     //                    COPIES                     //
     double makeImageCopyJmagick( List imgs, String appendage ) throws Exception
          long start = System.currentTimeMillis();
          int size = imgs.size();
          for ( int i=0;i<size;i++ )
               File f = (File) imgs.get( i );
               String imgPath = f.getAbsolutePath();
               String copyPath = imgPath.substring(0, imgPath.length()-4) + "Jmagick"+appendage+".jpg";
               ImageInfo imgInfo = new ImageInfo( imgPath );
               MagickImage image = new MagickImage( imgInfo );
               image.setFileName( copyPath );
               //imgInfo.setQuality( 100 );
               image.writeImage( imgInfo );
          long stop = System.currentTimeMillis();
          return getElapsedTime( start, stop );
     double makeImageCopyJava2d( List imgs, String appendage ) throws Exception
          long start = System.currentTimeMillis();
          int size = imgs.size();
          for ( int i=0;i<size;i++ )
               File f = (File) imgs.get( i );
               String imgPath = f.getAbsolutePath();
               String copyPath = imgPath.substring(0, imgPath.length()-4) + "Java2d"+appendage+".jpg";
               File infile = new File( imgPath );
               BufferedImage im = ImageIO.read( infile );
               File outfile = new File( copyPath );
               ImageIO.write( im, "jpg", outfile );
          long stop = System.currentTimeMillis();
          return getElapsedTime( start, stop );
     void run() throws Exception
          File f = new File( "images" );
          List imgs = parseDirImages( f );
          int size = imgs.size();
          //resize thumbnail
          System.out.println( "starting resize thumbnail test" );
          double java2dTime = scaleImageJava2d( imgs, MAX_THUMBSIZE, APPENDAGE_THUMB );
          System.out.println( "java 2d scaled "+size+" images to "+MAX_THUMBSIZE+" in "+java2dTime+ " seconds" );
          double jmagickTime = scaleImageJmagick( imgs, MAX_THUMBSIZE, APPENDAGE_THUMB );
          System.out.println( "jmagick scaled "+size+" images to "+MAX_THUMBSIZE+" in "+jmagickTime+ " seconds" );
          //resize medium
          System.out.println( "starting resize medium test" );
          java2dTime = scaleImageJava2d( imgs, MAX_IMAGESIZE, APPENDAGE_MED_COPY );
          System.out.println( "java 2d scaled "+size+" images to "+MAX_IMAGESIZE+" in "+java2dTime+ " seconds" );
          jmagickTime = scaleImageJmagick( imgs, MAX_IMAGESIZE, APPENDAGE_MED_COPY );
          System.out.println( "jmagick scaled "+size+" images to "+MAX_IMAGESIZE+" in "+jmagickTime+ " seconds" );
          //copy test
          System.out.println( "starting copy test" );
          java2dTime = makeImageCopyJava2d( imgs, APPENDAGE_COPY );
          System.out.println( "java 2d copied "+size+" images in "+java2dTime+ " seconds" );
          jmagickTime = makeImageCopyJmagick( imgs, APPENDAGE_COPY );
          System.out.println( "jmagick copied "+size+" images in "+jmagickTime+ " seconds" );
     public static void main(String[] args)
          try
               JmagickVsJava2d jdt = new JmagickVsJava2d();
               jdt.run();
          catch ( Exception e )
               e.printStackTrace();
     //               UTILITY METHODS                    //
     static boolean isOriginal( String filename )
          int x;
          return (     (x = filename.indexOf( APPENDAGE_THUMB )) < 0 &&
                         (x = filename.indexOf( APPENDAGE_COPY )) < 0 &&
                         (x = filename.indexOf( APPENDAGE_MED_COPY )) < 0 );
     static boolean isImage( String filename )
          boolean isImage = false;
          int len = filename.length();
          String ext = filename.substring( len - 3 );
          isImage =      "jpg".equalsIgnoreCase( ext ) ||
                         "gif".equalsIgnoreCase( ext ) ||
                         "png".equalsIgnoreCase( ext );
          return isImage;
     private int[] getImageDimensions( int width, int height, int maxLen )
          int[] dimensions = new int[2];
          //get the larger of the 2 values
          int longest = width > height ? width : height;
          //determine what we need to divide by to get the longest side to be MAX_THUMBSIZE
          double divisor = (double)longest/(double)maxLen;
          double w = (double)width/divisor;
          double h = (double)height/divisor;
          dimensions[0] = (int) w;
          dimensions[1] = (int) h;
          return dimensions;
     private double getScale( int width, int height, int maxLen )
          double scale;
          //get the larger of the 2 values
          int longest = width > height ? width : height;
          return (double)maxLen/(double)longest;
     private double getElapsedTime( long start, long stop )
          long s = stop - start;
          double elapsed = (double) s/1000;     
          return elapsed;
     private List parseDirImages( File dir ) throws IOException     
          ArrayList imgFiles = new ArrayList();
          if ( dir.isDirectory() )
               File[] files = dir.listFiles();
               int len = files.length;
               for ( int i=0;i<len;i++ )
                    File f = files[ i ];
                    String filename = f.getName();
                    if ( isImage(filename) && isOriginal(filename) )
                         imgFiles.add( f );
               }//end for
          } //end if is directory
          else
               throw new IOException( dir.getName()+ "is not a valid directory." );
          return imgFiles;
     private void encodeJPEGImage( BufferedImage bi, String copyPath ) throws IOException
          if (bi != null && copyPath != null)
          {      // save image as Jpeg     
               FileOutputStream out = null;
               try
                    out = new FileOutputStream( copyPath );
               catch (java.io.FileNotFoundException fnf) {       
                    System.out.println("File Not Found");
               JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(out);
               com.sun.image.codec.jpeg.JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(bi);
               param.setQuality(0.99f, false);
               encoder.encode(bi);
               out.close();
     * Scale with Java 2 standard graphics API
     private void scaleAndSaveWithAffineTransform( double scale, BufferedImage srcImg, String copyPath )
          throws IOException
     AffineTransform xform = AffineTransform.getScaleInstance( scale, scale);
          RenderingHints hints = new RenderingHints(     RenderingHints.KEY_RENDERING,
                                                                 RenderingHints.VALUE_RENDER_QUALITY);
//          RenderingHints hints = new RenderingHints(     RenderingHints.KEY_INTERPOLATION,
//                                                                 RenderingHints.VALUE_INTERPOLATION_BICUBIC);
          //AffineTransformOp op = new AffineTransformOp( xform, hints );
          AffineTransformOp op = new AffineTransformOp( xform, AffineTransformOp.TYPE_BILINEAR );
          BufferedImage dstImg = op.createCompatibleDestImage( srcImg, srcImg.getColorModel() );
          BufferedImage out = op.filter(srcImg, dstImg);
          encodeJPEGImage( out, copyPath );
     * Scale an image using the JAI API
     private void scaleAndSaveWithJAI( double scale, BufferedImage srcImg, String destName )
          throws IOException
          //using AffineTransform
          AffineTransform transform = AffineTransform.getScaleInstance( scale, scale);
          Interpolation interpolation = Interpolation.getInstance(Interpolation.INTERP_BICUBIC);
          PlanarImage img = (PlanarImage)JAI.create( "affine", srcImg, transform, interpolation);
          FileOutputStream fos = new FileOutputStream (destName);
          ImageEncoder enc = ImageCodec.createImageEncoder( "JPEG", fos, null );
          enc.encode( img );
          fos.close();
     private void scaleAndSaveWithGraphics2d(     BufferedImage      im,
                                                            int                width,
                                                            int                height,
                                                            int                maxSize,
                                                            String                copyPath )
          throws IOException
               int[] dim = getImageDimensions( width, height, maxSize );
               int tw = dim[ 0 ];
               int th = dim[ 1 ];
               HashMap hints = new HashMap( 2 );
               hints.put( RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON );
               hints.put( RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY );
               BufferedImage thumb = new BufferedImage( tw, th, BufferedImage.TYPE_INT_RGB );
               Graphics2D g2D = thumb.createGraphics();
               g2D.setRenderingHints( hints );
               g2D.drawImage( im, 0, 0, tw, th, null );
               File outfile = new File( copyPath );
               ImageIO.write( thumb, "jpg", outfile );     

Answer 1

Hi, You were right,
the resulting quality when scaling images using the drawImage method is
miserable. Thus there is a getScaledInstance method provided by the
Image class. This Method allows us to specify the scaling algorithm
(AREA_AVERAGING, SMOOTH, FAST...). Unforunately the jpeg encoder is only
capable to encode BufferedImage objects an not Image objects. So the
method listed below scales an Image, then uses a MediaTracker to wait
for the end of the scaling process an copy the scaled image into a
BufferedImage. One has to mention that the MediaTracker Contructer needs
a Component object. To me the reason for this is not really obvious, but
it seems we can feed it with any Component ( new Frame() should do the
job).
Regards,
Henning
private synchronized Image getScaledImage(Image ii, int nMaxWidth, int nMaxHeight) {
Image im = ii.getScaledInstance(nMaxWidth, nMaxHeight, Image.SCALE_AREA_AVERAGING);
MediaTracker mt = new MediaTracker(frame);
mt.addImage(im, 0);
try {
mt.waitForID(0);
} catch (Exception ie) {
System.out.println("exception scaling image:" + ie.getMessage());
if (mt.isErrorID(0)) {
// don't use the scaled icon if there was an error
im = ii;
System.out.println("getScaledImage():Error scaling the ImageIcon!!");
} else {
// scaling succeeded
return im;