Comment puis-je préserver la qualité de l'image lors d'une réduction significative de la taille d'images volumineuses ?

Réduction de la taille des images à grande échelle avec préservation de la qualité

La réduction excessive des images peut présenter des problèmes de qualité. Pour y remédier, diviser pour régner est une méthode efficace. Voici comment procéder :

1. Image originale :

2. Réduction incrémentielle :

Au lieu de redimensionner de 300 x 300 à 60 x60 en une seule étape, effectuez une mise à l'échelle progressivement :

1. Redimensionnez à 150 x 150 (1/2 de la dimension d'origine)
2. Redimensionner à 75x75 (1/2 de 150x150)
3. Redimensionner à 37x38 (1/2 de 75x75)
4. Redimensionner à 60x60 (1/2 de 37x38)

Chaque étape réduit la dimension de l'image de la moitié.

3. Résultat :

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

5. Implémentation Java :

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;
    }

}

Cette approche permet d'obtenir une qualité d'image sensiblement améliorée, en particulier lors d'une réduction significative de la taille.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!