How can I preserve image quality when downsizing large images significantly?

Large Scale Image Downsizing with Quality Preservation

Downsizing images excessively can present quality challenges. To tackle this, divide and conquer is an effective method. Here's how:

1. Original Image:

2. Incremental Downsizing:

Instead of resizing from 300x300 to 60x60 in one step, scale gradually:

1. Resize to 150x150 (1/2 of original dimension)
2. Resize to 75x75 (1/2 of 150x150)
3. Resize to 37x38 (1/2 of 75x75)
4. Resize to 60x60 (1/2 of 37x38)

Each step reduces the image dimension by half.

3. Result:

4. Comparison (One Step vs. Divide and Conquer):

5. Java Implementation:

public class DivideAndConquerImageResizer {

    public static main(String[] args) {
        // Load the original image
        BufferedImage original = ImageIO.read(...);

        // Create a scaled image
        BufferedImage scaled = null;

        Dimension currentSize = new Dimension(original.getWidth(), original.getHeight());
        Dimension desiredSize = new Dimension(60, 60);

        while (currentSize.getWidth() > desiredSize.getWidth()
               || currentSize.getHeight() > desiredSize.getHeight()) {
            // Halve the current size
            currentSize.width = (int) Math.ceil(currentSize.width / 2.0);
            currentSize.height = (int) Math.ceil(currentSize.height / 2.0);

            // Resize the image to the current size
            scaled = getScaledInstanceToFit(original, currentSize);
        }

        // Save the scaled image
        ImageIO.write(scaled, "jpg", ...);
    }

    public static BufferedImage getScaledInstanceToFit(BufferedImage img, Dimension size) {
        float scaleFactor = getScaleFactorToFit(img, size);
        return getScaledInstance(img, scaleFactor);
    }

    public static float getScaleFactorToFit(BufferedImage img, Dimension size) {
        float scale = 1f;
        if (img != null) {
            int imageWidth = img.getWidth();
            int imageHeight = img.getHeight();
            scale = getScaleFactorToFit(new Dimension(imageWidth, imageHeight), size);
        }
        return scale;
    }

    public static float getScaleFactorToFit(Dimension original, Dimension toFit) {
        float scale = 1f;
        if (original != null && toFit != null) {
            float dScaleWidth = getScaleFactor(original.width, toFit.width);
            float dScaleHeight = getScaleFactor(original.height, toFit.height);
            scale = Math.min(dScaleHeight, dScaleWidth);
        }
        return scale;
    }

    public static float getScaleFactor(int iMasterSize, int iTargetSize) {
        float scale = 1;
        if (iMasterSize > iTargetSize) {
            scale = (float) iTargetSize / (float) iMasterSize;
        } else {
            scale = (float) iTargetSize / (float) iMasterSize;
        }
        return scale;
    }

    public static BufferedImage getScaledInstance(BufferedImage img, double dScaleFactor) {
        BufferedImage imgBuffer = null;
        imgBuffer = getScaledInstance(img, dScaleFactor, RenderingHints.VALUE_INTERPOLATION_BILINEAR, true);
        return imgBuffer;
    }

}

This approach yields noticeably improved image quality, especially when downsizing significantly.

The above is the detailed content of How can I preserve image quality when downsizing large images significantly?. For more information, please follow other related articles on the PHP Chinese website!