Kuantisasi Warna GIF/Imej yang Berkesan

Dalam pengaturcaraan Java, kuantisasi warna memainkan peranan penting dalam mengoptimumkan palet warna imej atau fail GIF. Proses ini melibatkan pengurangan bilangan warna sambil mengekalkan perwakilan imej asal yang boleh diterima secara visual.

Pernyataan Masalah:

Kod yang disediakan nampaknya tidak cekap dalam mengurangkan warna dengan berkesan. Apabila mengurangkan imej dengan lebih daripada 256 warna kepada 256, ia menghasilkan ralat yang ketara, seperti merah menjadi biru. Ini menunjukkan bahawa algoritma bergelut untuk mengenal pasti dan mengekalkan warna penting dalam imej.

Algoritma Disyorkan:

• Median Cut: Algoritma ini secara rekursif membahagikan ruang warna kepada dua bahagian berdasarkan nilai warna median, mencipta pokok binari. Ia kemudian memilih subpokok dengan variasi warna terkecil sebagai nod daun, mewakili palet warna akhir.
• Berasaskan Populasi: Algoritma ini mengisih warna mengikut populasi (frekuensi) dalam imej dan mencipta palet dengan memilih bahagian atas "n" paling kerap warna.
• k-Bermaksud: Algoritma ini membahagikan ruang warna kepada gugusan "k", di mana setiap gugusan diwakili oleh nilai warna puratanya. Kluster centroid kemudiannya digunakan untuk membentuk palet warna.

Sampel Pelaksanaan:

Berikut ialah contoh pelaksanaan algoritma Median Cut dalam Java:

import java.util.Arrays;
import java.util.Comparator;
import java.awt.image.BufferedImage;

public class MedianCutQuantizer {

    public static void quantize(BufferedImage image, int colors) {
        int[] pixels = image.getRGB(0, 0, image.getWidth(), image.getHeight(), null, 0, image.getWidth());
        Arrays.sort(pixels); // Sort pixels by red, green, and blue channel values

        // Create a binary tree representation of the color space
        TreeNode root = new TreeNode(pixels);

        // Recursively divide the color space and create the palette
        TreeNode[] palette = new TreeNode[colors];
        for (int i = 0; i < colors; i++) {
            palette[i] = root;
            root = divide(root);
        }

        // Replace pixels with their corresponding palette colors
        for (int i = 0; i < pixels.length; i++) {
            pixels[i] = getClosestColor(pixels[i], palette);
        }

        image.setRGB(0, 0, image.getWidth(), image.getHeight(), pixels, 0, image.getWidth());
    }

    private static TreeNode divide(TreeNode node) {
        // Find the median color value
        int median = node.getMedianValue();

        // Create two new nodes, one for each half of the color range
        TreeNode left = new TreeNode();
        TreeNode right = new TreeNode();

        // Divide the pixels into two halves
        for (int i = node.start; i < node.end; i++) {
            if (node.pixels[i] <= median) {
                left.addPixel(node.pixels[i]);
            } else {
                right.addPixel(node.pixels[i]);
            }
        }

        return left.count > right.count ? left : right;
    }

    private static int getClosestColor(int pixel, TreeNode[] palette) {
        int minDistance = Integer.MAX_VALUE;
        int closestColor = 0;

        for (TreeNode node : palette) {
            int distance = getDistance(pixel, node.getAverageValue());
            if (distance < minDistance) {
                minDistance = distance;
                closestColor = node.getAverageValue();
            }
        }

        return closestColor;
    }

    // Utility methods

    private static int getDistance(int color1, int color2) {
        int r1 = (color1 >> 16) & 0xFF;
        int g1 = (color1 >> 8) & 0xFF;
        int b1 = color1 & 0xFF;

        int r2 = (color2 >> 16) & 0xFF;
        int g2 = (color2 >> 8) & 0xFF;
        int b2 = color2 & 0xFF;

        return (r1 - r2) * (r1 - r2) + (g1 - g2) * (g1 - g2) + (b1 - b2) * (b1 - b2);
    }

    private static class TreeNode {
        int start;
        int end;
        int count;
        int[] pixels;
        Integer averageValue;

        public TreeNode() {
            this(new int[0], 0, 0);
        }

        public TreeNode(int[] pixels, int start, int end) {
            this.pixels = pixels;
            this.start = start;
            this.end = end;

            count = end - start;
        }

        public int getMedianValue() {
            return pixels[(start + end) / 2];
        }

        public int getAverageValue() {
            if (averageValue == null) {
                int r = 0;
                int g = 0;
                int b = 0;

                for (int i = start; i < end; i++) {
                    int pixel = pixels[i];

                    r += (pixel >> 16) & 0xFF;
                    g += (pixel >> 8) & 0xFF;
                    b += pixel & 0xFF;
                }

                averageValue = (r / count) << 16 | (g / count) << 8 | b / count;
            }

            return averageValue;
        }

        public void addPixel(int pixel) {
            int[] newPixels = new int[pixels.length + 1];

            System.arraycopy(pixels, start, newPixels, start, end);
            newPixels[end] = pixel;

            pixels = newPixels;
            end++;
            count = end - start;

            averageValue = null;
        }
    }
}

Menggunakan pelaksanaan ini atau algoritma lain yang serupa boleh meningkatkan proses pengkuantitian warna dengan ketara dalam aplikasi Java anda, yang membawa kepada hasil yang boleh diterima secara visual apabila mengurangkan warna imej kepada 256 atau kurang.

Atas ialah kandungan terperinci Mengapakah kod Java yang disediakan untuk pengkuantitian warna bergelut untuk mengurangkan warna secara berkesan, terutamanya apabila mengurangkan imej dengan lebih daripada 256 warna kepada 256, mengakibatkan ralat ketara seperti semula. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!