Wie kann ich die Bildqualität beibehalten, wenn ich große Bilder erheblich verkleinere?

Großformatige Bildverkleinerung unter Beibehaltung der Qualität

Eine übermäßige Bildverkleinerung kann zu Qualitätsproblemen führen. Um dieses Problem anzugehen, ist „Teile und herrsche“ eine wirksame Methode. So geht's:

1. Originalbild:

2. Inkrementelle Verkleinerung:

Anstatt die Größe in einem Schritt von 300x300 auf 60x60 zu ändern, skalieren Sie schrittweise:

1. Größe auf 150x150 (die Hälfte der Originalabmessung) ändern
2. Größe auf 75x75 (die Hälfte von.) ändern 150x150)
3. Größe ändern auf 37x38 (1/2 von 75x75)
4. Größe ändern auf 60x60 (1/2 von 37x38)

Jeder Schritt verringert die Bildgröße um die Hälfte.

3. Ergebnis:

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

5. Java-Implementierung:

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

}

Dieser Ansatz führt zu einer spürbar verbesserten Bildqualität, insbesondere bei deutlicher Verkleinerung.

Das obige ist der detaillierte Inhalt vonWie kann ich die Bildqualität beibehalten, wenn ich große Bilder erheblich verkleinere?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!